Revision 0:d6c40db60579, committed 2017-02-09

Comitter:

VicOnCampusGeel

Date:

Thu Feb 09 08:28:08 2017 +0000

Commit message:

start;

Changed in this revision

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/FlankDetectie.h	Thu Feb 09 08:28:08 2017 +0000
@@ -0,0 +1,45 @@
+//------------------------------------------------------------------------------
+void dalende_flank( void )   // logisch  niveau HOOG  gaat LAAG
+{
+    if( timer.read_us()> min_idle) {
+        // pas tellen als er voldoende lange pulsen zijn
+        eHL_cnt++  ; // event = dalende flank
+        dt_High[eHL_cnt] = timer.read_us();
+        timer.reset();   // Hierdoor wordt de duurtijd van elke puls gemeten
+        // als timer niet gereset wordt, wordt de tijd van de flank
+        // geregistreerd sinds de start van de tijdsregistratie
+    }
+}
+
+//------------------------------------------------------------------------------
+void stijgende_flank( void )   // logisch  niveau LAAG gaat HOOG
+{
+    if( timer.read_us()> min_idle) {
+        // pas tellen als er voldoende lange pulsen zijn
+        eLH_cnt++; // event = stijgende flank
+        dt_Low[eLH_cnt] = timer.read_us();
+        timer.reset(); // elke pulsduur vanaf nul meten
+             // als timer niet gereset wordt, wordt de tijd van de flank
+             // geregistreerd sinds de start van de tijdsregistratie
+
+    }
+}
+
+//------------------------------------------------------------------------------
+void print_pulstrein()   // als debug =1 via terminal
+{
+    max_cnt=0;
+    if (eLH_cnt>eHL_cnt) {
+        max_cnt =eLH_cnt;
+    } else {
+        max_cnt =eHL_cnt;
+    }
+    printf("\r\nRapporteer de geregistreerde pulsen\r\n");
+    printf("%d :1ste_Dtd_Low: %d :us: %d :1ste_Dtd_High: %d :us\r\n", eLH_cnt,dt_Low[0] ,eHL_cnt, dt_High[0]);
+    if (debug ) { // volledige pulstrin naar terminal
+    
+        for (int i=0; (i < max_cnt+1); i++) {
+            printf("%d :Dtd_laag: %d :us_Dtd_hoog: %d :us\r\n", i,dt_Low[i] ,dt_High[i] );
+        }
+    }
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Ghost_Codes.h	Thu Feb 09 08:28:08 2017 +0000
@@ -0,0 +1,67 @@
+/*
+Ghostcode enkel geldig voor OPTIMA projector
+andere vertalingen moet je nog programmeren
+Na een reset, wordt de optima menu code verzonden,
+bij elke reset.
+Als je de blauwe user knop indrukt wordt de laatst
+ontvangen code terug uitgestuurd.
+
+De variabelen zijn unsigned long.
+Enkel de 32- laagste bits worden verstuurd.
+Langere code kunnen een aangepaste variabele vragen!!!!!
+*/
+
+
+unsigned long Get_Ghost_Code(unsigned long NEC_Code)
+{ 
+    unsigned long Ghost_Code;
+    switch (NEC_Code) {
+        case 0xFA05F708:
+            strcpy(Toets,"Up");
+            Ghost_Code=0x3EC1CD32; // optima Page+ toets
+            break;
+        case 0xFF00F708:
+            strcpy(Toets,"Down");
+            Ghost_Code=0x00FFCD32;// optima Page- toets
+            break;
+        case 0xF708F708:
+            strcpy(Toets,"Left");
+            Ghost_Code=0x00FFCD32;// optima Source toets
+            break;
+        case 0xFE01F708:
+            strcpy(Toets,"Right");
+            Ghost_Code=0x00FFCD32;// optima Resync toets
+            break;
+        case 0xFB04F708:
+            strcpy(Toets,"Center");// optima Center toets
+            Ghost_Code=0x00FFCD32;
+            break;
+       case 0xE41BF708: // OFF key
+            strcpy(Toets,"OFF Key");
+            Ghost_Code=0x00FFCD32; // // optima Power toets
+            break;
+      case 0xE51AF708: // C key
+            strcpy(Toets,"C Key");
+            Ghost_Code=0x00FFCD32; // // optima enter toets
+            break;
+         case 0xE11EF708: // B key
+            strcpy(Toets,"A-Key");
+            Ghost_Code=0x00FFCD32; // // optima Brightness toets
+            break;
+       case 0xE01FF708: // A key
+            strcpy(Toets,"A-Key");
+            Ghost_Code=0x7788CD32; // // optima menu toets
+            break;
+      case 0x0: // Default na reset
+            strcpy(Toets,"Null code  ");
+            Ghost_Code=0x7788CD32; // // optima menu toets
+            break;
+
+        default:
+            Ghost_Code=NEC_Code; // Originele code behouden
+            break;
+    }
+    return(Ghost_Code);
+
+}
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/LED_Codes.h	Thu Feb 09 08:28:08 2017 +0000
@@ -0,0 +1,34 @@
+/*
+Hier wordt de betekenis van de LED indicators tijdens het zenden besproken
+led1  :Rood
+led2  :Oranje
+led3  :Groen 
+led4  :Groen ld2 op nucleobord 
+----------------------------------------------------------------
+1.Na reset of bij opstart van het systeem
+    led1 = 0;     // reset toestand
+    led2 = PTin;  // Blijft hoog als er GEEN IR wordt ontvangen
+    led3 = 0;     // andere LEDs gedoofd
+    led4 = 0;     // Groene LEDje LD2 op het NUCLEO bordje
+
+2. In rust als er niets gebeurt op IR_TX en IR_RX
+     led1 = (flag & 1);  // flash LED1 in wacht mode elke 2 seconden
+     led2 =PTin;         // Led2 brandt in rust
+     led3 =!PTin;        // Led3 gedooft in rust
+     led4 =(flag &2);    // flash LED4 in wacht mode elke 4 seconden
+
+3. Bij het indrukken van de Blauwe USER_BUTTON
+    led3 = 1; // Groene LED aan tijdens verzenden van de code
+
+4. IR ontvanger detecteert een dalende flank op PTin : start registratie
+   led2 =0; // Oranje  LED dooft
+   led3 =1; // Groen LED aan
+ 
+5. Na het ontvangen van een pulstrein op de IR_Receiver
+          Rood: led1 = 1; // pulstrein berekend
+        Oranje: led2 = 0;
+        Groen : led3 = 0;
+       ld2led4:      = PTin; // normaal 1 in rust
+
+
+*/
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/RX_Pulstrein.h	Thu Feb 09 08:28:08 2017 +0000
@@ -0,0 +1,34 @@
+void RX_pulstrein()
+{
+// registreer alle niveauveranderingen van het signaal van de IR detector IR_RX
+// met hun duurtijd in een array.
+// Decodeer deze data naar een uitgezonden code volgens het NEC protocol.
+           timer.start();        // bittime counter
+           timer.reset();
+            while( !Timed_Out) {
+ 
+                while( !PTin and !Timed_Out) {    // is laag, wacht op stijgende flank)
+                    Timed_Out = (timer.read_ms()>200) ;
+                }
+                if (!Timed_Out) {
+                    stijgende_flank();   // gedetecteerd, dus registreer duurtijd laag niveau
+               led2 = !led2; // Oranje LED flikkert tijdens ontvangen
+                 }
+                while( PTin and !Timed_Out) { // is hoog doe niets, wacht op dalende flank
+                    Timed_Out = (timer.read_ms()>200) ;
+                }
+                if (!Timed_Out) {
+                    dalende_flank();  // gedetecteerd, dus registreer duurtijd hoog niveau
+                led2 = !led2; // Oranje LED flikkert tijdens ontvangen
+                }
+            }
+            printf("Timed_out eLH_cnt: %d :eHL_cnt: %d \r\n",eLH_cnt,eHL_cnt);
+            print_pulstrein(); // naar Hyperterminal
+            analyseer_pulstrein(); // naar terminal
+            
+            led1 = 1; // pulstrein berekend
+            led2 = 0;
+            led3 = 0;
+            led4 = PTin;
+            wait(.1);
+}
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/TX_IR_NEC.h	Thu Feb 09 08:28:08 2017 +0000
@@ -0,0 +1,119 @@
+// -----------NEC Pulscode Timing ----------------------------------------------
+const float IR_Frequentie=38000.0; // 38kHZ IR frequentie
+const float IR_ON=0.5;  // stuur dutycycle 50% vervangt IR=0;
+const float IR_OFF=0.0; // stuur dutycycle 0%  vervangt IR=1;
+// Dutycle aansturing via de basis van de transistor en PWM signaal
+// vervangt aansturing via de emittor via IR=0 of IR=1 via pin TX
+// D3 MOET wel als DigitalOut IR(D3) pin gedefinieerd worden
+// D3 MOET laag staan om te kunnen zenden
+// voor meer bereik, de extra testpin (anode van de diode) aan massa leggen
+
+const int NEC_Time=562; // in microsec
+const int NEC_Start_IRON=562*16;// in microsec
+const int NEC_Start_IROFF=562*8;// in microsec
+const int NEC_FrameTime=108; // ms
+
+unsigned int NEC_Code=0xFB04F708; // NEC center toets
+
+// FB04 High bytes = toetscode
+// F708 low Bytes Fabrikant code voor NEC
+// wordt low bit first en low byte first uitgezonden
+
+//  IRLED=IR_OFF; // Stop sending IR Carrier. Zet PWM dutycycle op 0%
+//  IRLED=IR_ON ; // Send IR Carrier. Zet PWM dutycycle op 50%
+
+// -----------------------------------------------------------------------------
+Timer Frame_timer; // Frame_timer voor frame timing
+Timer timer;       // bittime counter
+
+//---------------------------------------------------------------------------------------------------------------
+void IR_Code_L0()    // Logisch=0 IR Code van de fabrikant
+{
+    timer.reset();
+     IRLED=IR_ON ; // Send IR Carrier
+    while (timer.read_us()< NEC_Time) { // Light on = 1TU for Nec
+        /* Keep sending Ir signaal */
+    }
+    timer.reset();
+    IRLED=IR_OFF ; // Stop sending IR Carrier
+    while (timer.read_us()< NEC_Time) { // Light off = 1TU for Nec
+        /* Stop sending Ir signaal */
+    }
+}
+//---------------------------------------------------------------------------------------------------------------
+void IR_Code_L1()    // // Logisch=1 IR Code van de fabrikant
+{
+    timer.reset();
+    IRLED=IR_ON ; // Send IR Carrier
+    while (timer.read_us()< NEC_Time) {// Light on = 1TU for Nec
+        /* Keep sending Ir signaal */
+    }
+    timer.reset();
+    IRLED=IR_OFF ; // Stop sending IR Carrier
+    while (timer.read_us()< (NEC_Time*3)) { // Light off = 3TU for NEC
+        /* Stop sending Ir signaal */
+    }
+}
+//---------------------------------------------------------------------------------------------------------------
+void stuur_Code( unsigned int NEC_Code)
+{ 
+// stuur de NEC_code, met NEC timing
+// inclusief    Header frame
+//              code + 1 extra bit
+//              repeat code ( na de frame time)
+
+    int bit=0;
+  IR_disable=0 ; // om de emitter op massa te trekken
+                  // zodat via de basis verder kan gestuurd worden
+    IRLED.period(1.0/IR_Frequentie); //Drive IR LED data pin with 38Khz PWM Carrier
+    IRLED = IR_OFF;               // Dutycycle 0% op basis van de transistor
+    Frame_timer.start();  // Frametime counter
+    timer.start();        // bittime counter
+    
+// ----- Start sending Command frame --------------------------
+    IRLED=IR_ON ; // Send IR Carrier. Op Basis van de transistor Dutycycle 50%
+    Frame_timer.reset();
+    timer.reset();
+    while (timer.read_us()< NEC_Start_IRON) {// Light on
+        /* Keep sending Ir signaal */
+    }
+    timer.reset();
+    IRLED=IR_OFF ; // Stop sending IR Carrier
+    while (timer.read_us()< NEC_Start_IROFF) { // Light off
+        /* Stop sending Ir signaal */
+    }
+// -- Start sending 32 NEC Code ------------------------------------------------
+    for (int i=0; i < 32; i++) {
+        bit= (NEC_Code &1); // low bit first
+        NEC_Code=(NEC_Code>>1); // volgende te versturen bit klaarzetten
+        if (bit) {
+            IR_Code_L1(); // stuur logisch 1
+        } else {
+            IR_Code_L0(); // stuur logisch 0
+        }
+    }
+    IR_Code_L1(); // stuur logisch 1 send 1 trailing bit
+// --- Start sending IR=1 Frametime -----------------------------------------
+    IRLED=IR_OFF; // Stop sending IR Carrier
+    while (Frame_timer.read_ms()< NEC_FrameTime) { // Light off
+        /* Stop sending Ir signaal */
+    }
+// --- Start sending Repeat frame -----------------------------------------
+    timer.reset();
+    IRLED=IR_ON ; // Send IR Carrier
+    while (timer.read_us()< NEC_Start_IRON) {// Light on
+        /* Keep sending Ir signaal */
+    }
+    timer.reset();
+    IRLED=IR_OFF ; // Stop sending IR Carrier
+    while (timer.read_us()< (NEC_Start_IROFF/2)) { // Light off
+        /* Stop sending Ir signaal */
+    }
+    IR_Code_L0(); // stuur logisch 0
+    IR_disable=1 ; // om de emitter op 1 te trekken
+                   // IR transmitter valt af
+ 
+// --- Stop sending Repeat frame ------------------------------
+    Frame_timer.stop();
+    timer.stop();
+}
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/analyseer_pulstrein.h	Thu Feb 09 08:28:08 2017 +0000
@@ -0,0 +1,108 @@
+//---------------------------------------------------------------------------------------------------------------
+void analyseer_pulstrein()    //
+{
+    int min_dt=0,min_dt_L=0,min_dt_H=0;
+    int max_dt=0,max_dt_L=0,max_dt_H=0;
+    int DT_Lowlevel=0,DT_Highlevel=0;
+    const int TH_pulsduur_Low=2000,TH_pulsduur_High=2000; // Voor pulsduur registratie
+
+    int j=0;
+    char sL[30]=":DT_Low:";
+    char sH[30]=":DT_High:",ms[30]=":microsec";
+    char IRCFile[]=""; // eventueel de naam van een File op disk
+    int termlog = 0;  // terminal log default off
+    int Pulsduur=1;   // Pulstrein met pulsduur analyse
+    if (termlog) { //terminal logging is on
+        printf("\n---Start analyse pulstrein: %s \n\r",IRCFile);
+        printf("--------------------------------\n\r");
+    }
+    if (eHL_cnt>eLH_cnt) {
+        max_cnt =eHL_cnt;
+    } else {
+        max_cnt =eLH_cnt;
+    }
+    if (debug) {
+        printf("---Aantal pulsen Hoog: %5d :Laag:%5d : max_cnt: %5d\r\n",eHL_cnt,eLH_cnt,max_cnt);
+    }
+    for (int i=0; i < max_cnt+1; i++) { // 1: forloop start na de startpuls
+        if (Pulsduur) { // 2: de individuele tijden lezen als pulsduur
+            if (debug) {
+                printf( "%d %s %d %s %d %s \r\n", j,sL ,dt_Low[i],sH,dt_High[i],ms );
+            }
+            if (i==0) { // 3: hoofdloop uitzonderingen
+                DT_Lowlevel=0;      // DT_Lowlevel : Tel de Totale tijd hoog van de pulstrein
+                DT_Highlevel=0;    // DT_Highlevel : Tel de Totale tijd laag van de pulstrein
+            } else { // 4: subloop 1=< i =<
+
+                if (i==1) { // Init pulsduuren na lezen eerste puls
+                    min_dt_H = dt_High[1];  // Bepaal de min en maximale pulsduur van de bits na de startpuls :
+                    min_dt_L = dt_Low[1]; // Bepaal de kleinste pulsduur: PulsduurHoog of PulsduurLaag
+                    max_dt_H = dt_High[1];  // Bepaal de min en maximale pulsduur van de bits na de startpuls :
+                    max_dt_L = dt_Low[1]; // Bepaal de kleinste pulsduur: PulsduurHoog of PulsduurLaag
+                    min_dt =min_dt_H;
+                    if ( min_dt > min_dt_L) {
+                        min_dt = min_dt_L;
+                    }
+                } // close if init pulsduuren
+            } // 3: einde uitzonderingen i > 1 normaal behandelen
+
+            if ((dt_Low[i] > 0)and (dt_Low[i] < TH_pulsduur_High)) {
+                DT_Highlevel=DT_Highlevel+dt_Low[i];    // DT_Highlevel : Tel de Totale tijd laag van de pulstrein
+                if ( min_dt_L > dt_Low[i]) {
+                    min_dt_L = dt_Low[i];
+                }
+                if ( max_dt_L < dt_Low[i]) {
+                    max_dt_L = dt_Low[i];
+                }
+                if ( min_dt > dt_Low[i]) {
+                    min_dt = dt_Low[i];     // Bepaal de kleinste pulsduur: PulsduurHoog of PulsduurLaag
+                }
+            }
+
+            if ((dt_High[i] > 0)and (dt_High[i] < TH_pulsduur_Low)) {
+                DT_Lowlevel=DT_Lowlevel+dt_High[i];  // DT_Lowlevel : Tel de Totale tijd hoog van de pulstrein
+                if( min_dt_H > dt_High[i]) {
+                    min_dt_H = dt_High[i];
+                }
+                if( max_dt_H < dt_High[i]) {
+                    max_dt_H = dt_High[i];
+                }
+                if( min_dt > dt_High[i]) {
+                    min_dt = dt_High[i];
+                }
+            }
+        }     else { // 2: else pulsduur
+            if (debug) {
+                printf("%d: Flank  L-H :%d: Flank  H-L:%d:us = pulsduur_H:%d\r\n", i,dt_High[i] ,dt_Low[i],  dt_Low[i]-dt_High[i] );
+            }
+        } //2: close pulsduur
+        
+        max_dt=max_dt_H;
+        if (max_dt<max_dt_L) {
+            max_dt =max_dt_L;
+        }
+    } // 1: close for loop
+
+    if ((termlog )and (max_cnt>1)) { //terminal logging is on, print analyseresultaat
+        printf("---Aantal pulsen Low   : %5d\r\n",eHL_cnt);
+        printf("---Aantal pulsen High  : %5d\r\n",eLH_cnt);
+        printf("---Aantal max_cnt      : %5d\r\n",max_cnt);
+        printf("---Startpuls duurtijd Low   : %5d\r\n",dt_Low[0]);
+        printf("---Startpuls duurtijd High  : %5d\r\n",dt_High[0]);
+        printf("------------------------------------\r\n" );
+        printf("---Minumum pulsduur Low     : %5d\r\n",min_dt_L);
+        printf("---Minimum pulsduur High    : %5d\r\n",min_dt_H);
+        printf("---minimum pulsduur         : %5d\r\n",min_dt);
+        printf("------------------------------------\r\n" );
+        printf("---Maximum pulsduur Low     : %5d\r\n",max_dt_L);
+        printf("---Maximum pulsduur High    : %5d\r\n",max_dt_H);
+        printf("---Maximum pulsduur         : %5d\r\n",max_dt);
+        printf("------------------------------------\r\n" );
+        printf("---minimum Bittijd binair 0 : %5d\r\n",min_dt_L + min_dt_H);
+        printf("---maximum Bittijd binair 1 : %5d\r\n",max_dt_H+max_dt_L);
+        printf("------------------------------------\r\n" );
+        printf("---Totale pulstreinduurtijd High   :%7d\r\n",DT_Highlevel);
+        printf("---Totale pulstreinduurtijd Low    :%7d\r\n",DT_Lowlevel);
+        printf("---Totale pulstreinduurtijd        :%7d\r\n",DT_Highlevel+DT_Lowlevel);
+    }
+} //0:
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/hello_msg.h	Thu Feb 09 08:28:08 2017 +0000
@@ -0,0 +1,17 @@
+ //--- Print Hello bericht naar terminal ----------------------------------------
+    printf("\r\n----------------------------------------------------\r\n");
+    printf("mbed NUCLEO-F091RC microprocessor bord\r\n");
+    printf("         Demo van een\r\n");
+    printf("Infrarood  Zender   - ontvanger \r\n");
+    printf("via  :  PWMpin D9 - RXpin D5 :  TXpin D3: disabled \r\n\r\n");
+/*
+    printf("emitter van de transistor aan massa te leggen via draadbrug");
+    printf("wordt in een latere versie van het bordje opgelost)";
+    printf("om voldoende stroom door de IR_LED te sturen, om voldoende");
+    printf("Krachtig te zijn om ook via reflecties op het projectorscherm");
+    printtf("te kunnen reageren");
+ */
+    printf("STEM workshop KU Leuven Campus Geel\r\n");
+    printf("Naam deelnemer : uw naam\r\n");
+    printf("Naam van de school : ......\r\n");
+    printf("----------------------------------------------------\r\n");

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/main.cpp	Thu Feb 09 08:28:08 2017 +0000
@@ -0,0 +1,185 @@
+/*------------------------------------------------------------------------------
+Hardware : NUCLEO-F091RC board + IR-RX IR-Tx board + Soundcardscoop
+STEM project, KU Leuven Campus Geel
+-------------------------------------------------------------------
+Pin PB_3 : D3: IR-Tx  Receiver CN9 pin3 --> wordt een TX disable niveau bij 1
+                                        --> wordt een TX enable  niveau bij 0
+
+Pin PB_4 : D5: IR-Rx  Receiver CN9 pin5 --> pin3 van de IR Receiver
+Pin PC_7 : D9: PWM aansturing voor 38kHz op basis van de transistor BC547B
+    de emittor van de transistor wordt naar massa aangesloten
+    Collector is verbonden met 3,3V, IR-LED + serieweerstand van 18 Ohm
+    zodat de stroom door de IR LED voldoende groot (>50mA )kan zijn
+    om een grote afstand te kunnen overbruggen ( >5m)
+----------------------------------------
+---- Programmacode update 7-2-2017 -----
+----------------------------------------
+Volledig functioneel.
+Via een terminal programma,( bv.  TerraTerm, Putty,Hyperterminal,.....)
+zijn alle stappen die het programma doorloopt te volgen
+Via de 'line in' van de soundcard, en het software programma
+Cooledit ( geluid bewerkingsprogramma) of via Soundcard_Scope
+zijn de ontvangen IR codes te analyseren op de PC.
+
+1. Na reset zendt de IR-Tx LED de default GHost_Code uit
+2. Lees via IR_Rx een NEC IR ontvangen code in en decodeer naar de fabrikantcode
+3. Stuur de overeenkomstige GHost_Code uit via IR_Tx met de user_Button
+4. stuur de laatst gestuurde code nogmaals via de user_button
+5. test op correcte NEC_Codes om fouten van reflecties weg te filteren
+*/
+//------------------------------------------------------------------------------
+#ifndef TARGET_NUCLEO
+#define TARGET_NUCLEO
+#endif
+
+#include "mbed.h"
+Timer program_timer; // timing van de activiteit van het hoofdprogramma
+
+
+#ifdef TARGET_NUCLEO
+// Pinbenamingen zijn enkel geldig voor het NUCLEO-F091RC bordje
+// Voor andere bordjes, moet je de pinbenamingen aanpassen aan
+// de functionalitijd van de beschikbare pinnen.
+
+PwmOut IRLED(D9);       // IRLED freq. 38KHz via PWM CN9 Pin D9 (startpinnr at pin D0)
+DigitalOut IR_disable(D3); // =0 om de emitter op massa te leggen met beperkt zendvermogen
+                           //= 1 verhinder zenden
+DigitalIn PTin( D5 ); // Pulstrein_input: lees het niveau van de pulstrein=IR Receiver CN9 pin D5
+DigitalIn UserBlauw(USER_BUTTON); // PC_13 blauwe drukknop op het bordje
+
+DigitalOut led1( D8 ); // Rode Led
+DigitalOut led2( D7 ); // Oranje LED
+DigitalOut led3( D6 ); // Groene LED
+DigitalOut led4( D13); // PA_5 : LED op het BORDJE
+#endif
+
+//---------- Typecast alle variabelen ------------------------------------------
+
+int dt_High[100]; // max 100 te registreren pulsen laag niveau
+int dt_Low[100];  // max 100 te registreren pulsen hoog niveau
+int eHL_cnt=-1, eLH_cnt=-1,min_idle=1;
+int max_cnt=0;
+char Toets[30]="Geen toets";
+
+bool PInow=0; // Huidig ingangsniveau van de detector
+bool PI=0;    // Vorig  ingangsniveau van de detector
+bool IsHoog=0, IsLaag=0,Timed_Out=0;
+bool debug=0; // debuging flag, voor extra info naar terminal
+
+// -----------NEC Pulscode Timing voor TX --------------------------------------
+#include "TX_IR_NEC.h"
+
+//------------------------------------------------------------------------------
+// Analyseer de ontvangen pulstrein
+// Hieruit kun je informatie halen om andere pulscodetreinen te decoderen.
+// Hiervoor moet je dan de converteer routine pulstrein_to_NECcode.h
+// herschrijven.
+#include "analyseer_pulstrein.h"
+
+//------------------------------------------------------------------------------
+// Flankdetectie en pulsduurregistratie in de arrays
+// Hierna volgt de analyse van de pulstrein
+#include "FlankDetectie.h"
+#include "RX_Pulstrein.h"
+
+//------------------------------------------------------------------------------
+// converteer de pulstrein naar een NEC code
+// vervang deze code eventueel door uw eigen decodeerprogramma
+#include "pulstrein_to_NEC_code.h"
+
+//------------------------------------------------------------------------------
+// Reset alle variabelen van het programma
+void reset_vars()
+{
+    eLH_cnt=-1;   // telt het aantalsen hoog
+    eHL_cnt=-1;   // telt het aantalsen laag
+    dt_Low[0]=0;  // duurtijd van de puls  laag = stijgende flank getetecteer
+    dt_High[0]=0; // duurtijd van de puls  hoog = dalende flank getetecteer
+
+    led1 = 0;     // reset toestand
+    led2 = PTin;  // Blijft hoog als er GEEN IR wordt ontvangen
+    led3 = 0;     //andere LEDs gedoofd
+    led4 = 0;     // Groene LEDje LD2 op het NUCLEO bordje
+    IsHoog =PInow;  // actief hoge variabele
+    IsLaag =!PInow; // actief hoge variabele
+}
+//------------------------------------------------------------------------------
+// Vertaal de ontvangen NEC_codes in een GhostCode indien
+// aanwezig in de vertaaltabel.
+// Anders stuur de code ongewijzigd door.
+#include "Ghost_Codes.h"
+
+int main()
+{
+     unsigned long Ghost_Code=0x7788CD32; // Optima projector menu Code
+   unsigned long NEC_Code=Ghost_Code;   // NEC_Code = default na reset
+    unsigned long New_Code=Ghost_Code;   // NEC_Code = default na reset
+    int pr_cnt=0; // sec program counter
+    int flag=0;
+    program_timer.start(); // start timer
+    program_timer.reset(); // zet timer =0
+    PInow = PTin;  // lees het niveau vd RX pin pulstrein in rust
+//--- Print Hello bericht naar terminal ----------------------------------------
+ #include"hello_msg.h"
+ 
+ //------------------------------------------------------------------------------
+
+    while(1) { // hoofdloop stopt nooit
+        flag=program_timer.read_ms();
+        if  ( flag >  pr_cnt*1000 ) {
+            reset_vars();          // Reset alle variabelen elke seconde
+            Timed_Out=0;
+            pr_cnt++;
+            if (pr_cnt==1) { // stuur na 1 seconde de default ghost code uit
+                // na een reset.
+                stuur_Code(Ghost_Code);
+                printf("\n\rDefault Ghost code send : %x\n\r\n\r",Ghost_Code);
+            }
+            printf ("%d sec : Klaar om een nieuwe code te ontvangen:\r",pr_cnt);
+            printf ("%d \r",pr_cnt);
+        }
+
+        if (!UserBlauw) {        // userknop wordt ingedrukt
+            while(!UserBlauw) {} // wacht tot de toets wordt losgelaten
+            led3 =1; // Groene LED aan
+            // verstuur de laatste ontvangen code nogeens uit.
+            // of de default menucode voor de dataprojector na reset
+            // Ghostcode voorlopig enkel geldig voor de dataprojector Optima
+            // andere vertalingen moet je nog programmeren.
+
+            Ghost_Code= Get_Ghost_Code(NEC_Code);
+            printf("\r\nNEC code : %x vertaalt voor toets %s\r\n",NEC_Code,Toets);
+            stuur_Code(Ghost_Code);
+            printf("Ghost code send : %x\n\r\n\r",Ghost_Code);
+            wait(0.5);
+            reset_vars();          // Reset alle variabelen elke seconde
+
+        }
+        if (!PTin) { // IR ontvanger is hoog doe niets, wacht op dalende flank
+            // Dalende flank gedetecteerd, start dan de pulstreindetectie.
+            reset_vars();          // Reset alle variabelen elke seconde
+            Timed_Out=0;
+            led3 =1; // Groen LED aan
+            RX_pulstrein();
+            New_Code=pulstrein_to_NEC_Code(); // decodeer de pulstrein en genereer NEC_Code
+            if(New_Code!=0) {
+                if (NEC_Code != New_Code) { // codes ontvangen door reflecties wegfilteren
+                    NEC_Code=New_Code; // nieuwe codes mogen door user_button verzonden worden
+                    wait(0.1);
+                    Ghost_Code= Get_Ghost_Code(NEC_Code); // zoek bijhorende toetsnaam en GhostCode
+                    stuur_Code(Ghost_Code); // stuur de ontvangen NEC_code terug uit.
+                    // Stuur de ghostcode nog niet uit
+                    // Druk de blauwe user knop om de ghostcode uit te sturen
+                    printf("Ghost code : %x vertaald voor toets %s\r\n\r\n",Ghost_Code,Toets);
+                }
+            }
+        } else {
+            // geen IR ontvangen, programma blijft zichtbaar actief via de LEDs
+            flag=program_timer.read(); // lees seconden teller
+            led1 = (flag & 1);  // flash LED1 in wacht mode elke 2 seconden
+            led2 =PTin;         // Led2 brandt in rust
+            led3 =!PTin;        // Led3 gedooft in rust
+            led4 =(flag &2);    // flash LED4 in wacht mode elke 4 seconden
+        }
+    }
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mbed.bld	Thu Feb 09 08:28:08 2017 +0000
@@ -0,0 +1,1 @@
+http://mbed.org/users/mbed_official/code/mbed/builds/ad3be0349dc5
\ No newline at end of file

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/pulstrein_to_NEC_code.h	Thu Feb 09 08:28:08 2017 +0000
@@ -0,0 +1,80 @@
+//------------------------------------------------------------------------------
+/* converteer de pulstrein naar een NEC code van 32-bit
+
+element 0 van de array bevat de startsequentie
+laag - hoog en wordt dus niet vertaald in bits
+1 Pulstijd laag +  1 Pulstijd hoog = 0 Bit
+1 Pulstijd laag +  3 Pulstijd hoog = 1 Bit
+
+als de pulstijd HOOG minstens dubbel zo lang duurt als de pulstijd LAAG
+wordt er de bit 1 gemaakt voor de code.
+Alle andere voorwaarden geven een bit 0 voor de decodering,
+zodat de actief lage pulsen worden omgezet in een actief hoge code.
+
+Immers : een 1 in deze code, betekent IR-licht uitzenden op de Transmitter
+         een 0 betekent geen IR-licht uitzenden
+
+Terwijl: voor onze ontvanger geldt:
+         een 1 lezen, betekent GEEN licht ontvangen
+         een 0 lezen, betekent IR-licht ontvangen
+*/
+//------------------------------------------------------------------------------
+unsigned long pulstrein_to_NEC_Code()
+{
+    // long kan 64 bit integer code aan
+    const int BLen= 32 ; // Bit lengte van deze NEC_CODE
+    unsigned long  NEC_Code=0 ;// tot max 64 bit code
+    unsigned long flag=1;
+    char byte[4]= {0,0,0,0};
+    max_cnt=0;
+    if (eLH_cnt>eHL_cnt) {
+        max_cnt =eLH_cnt;
+    } else {
+        max_cnt =eHL_cnt;
+    }
+    if (max_cnt>BLen) { // enkel code produceren als 32-bit code volledig is
+        // low bit first - high bit last
+        for (int i=1; (i < BLen+1); i++) { // i = 0 is de startpuls
+            // i = 1 is bit 0 --- i = 32 bit 31
+            if ((dt_Low[i]*2 - dt_High[i] )>0) {
+                // digitale 0, niets bijtellen
+            } else {
+                // digitale 1 : flag die telkens 1 bit wordt geshift naar links bijtellen
+                NEC_Code = NEC_Code +flag;
+            }
+            flag=(flag<<1); // flag is flag * 2
+        }
+        printf("\r\nGelezen Nec_code        : %x\r\n",NEC_Code);
+        printf("\r\n");
+
+//    printf ("Druk op een toets om deze pulstrein weg te schrijven naar een file op de mBED \n\r");
+//    pc.getc();    // wacht op een toets ingedrukt in Terminal. Enkel voor debugging
+    }
+    
+    // test op de geldigheid van de ontvangen code
+    // byte 0 MOET het inverse zijn van byte 1
+    // en byte 3 MOET het inverse zijn van byte 4 om geldig te zijn
+    byte[0]=((NEC_Code >>0)  & 0xff);
+    byte[1]=!((NEC_Code>>8)  & 0xff); // invers moet gelijk zijn aan vorige byte
+    byte[2]=((NEC_Code>>16)  & 0xff);
+    byte[3]=!((NEC_Code>>24) & 0xff);// invers moet gelijk zijn aan vorige byte
+
+    if (byte[0]& byte[1]) { 
+    printf("\r\nOngeldige fabrikantcode: %x ",NEC_Code);
+    NEC_Code=0;         
+    }
+   if (byte[2]& byte[3]) {
+    printf("\r\nOngeldige toetscode: %x ",NEC_Code);
+    NEC_Code=0; 
+        
+       
+    }
+
+    return (NEC_Code); // big endian formaat
+/*
+    zowel de Sparkfun afstandsbediening als de Optoma projector
+    zijn gecodeerd volgens de NEC_Code pulstreinen
+*/
+}
+
+//------------------------------------------------------------------------------