Arduino
#include <Arduino.h> 

#define SAMPLES 128 
#define SAMPLING_RATE 1408 /* in Hz */ 
#define SAMPLING_TIME_US round(1000000.0/SAMPLING_RATE)  /* in microseconds */ 
#define SENSIVITY 100 

void sampleInQ(int16_t*, int16_t*); 
int16_t getMeanValue(int16_t*, int16_t); 
int detectDirection(int16_t* , int16_t*); 

int direction = 0; 
int16_t bufferI[SAMPLES] = {0}; 
int16_t bufferQ[SAMPLES] = {0}; 



void setup() 
{ 
  Serial.begin(38400); 
  Serial.println("Init done!"); 


  pinMode(BGT_ON, OUTPUT); 
  digitalWrite(BGT_ON, LOW); // Turn on the board 
} 


void loop() 
{ 
  sampleInQ(bufferI, bufferQ); 
  direction = detectDirection(bufferI, bufferQ); 
  if(direction > 0) 
  { 
    Serial.println("DOOR: OPEN"); 
  }else if(direction < 0){ 
    Serial.println("DOOR: CLOSE");    
  } 
} 



void sampleInQ(int16_t* buffI, int16_t* buffQ) 
{ 
  for (int i = 0; i < SAMPLES; i++) 
  { 
      buffI[i] = analogRead(CH_I); 
      buffQ[i] = analogRead(CH_Q); 
      delayMicroseconds(SAMPLING_TIME_US); 
  } 
} 


int16_t getMeanValue(int16_t* buff, int16_t length) 
{ 
  int16_t meanRet = 0; 
  int sum = 0; 
  for (int i = 0; i < length; i++) 
  { 
    sum += buff[i]; 
  } 
  meanRet = round((float)sum/(float)length); 
  return meanRet; 
} 



int detectDirection(int16_t* buffI, int16_t* buffQ) 
{ 
  int16_t directionRet = 0; 
  int indicator = 0; 
  bool edgechanged = true; 
  bool nextismax = true; 
  int16_t mean = 0; 
   
  mean  = getMeanValue(buffI, SAMPLES); 
  for (int i = 0; i < (SAMPLES - 1); i++) 
  { 
    if ((buffI[i] < (mean - SENSIVITY)) || (buffI[i] > (mean + SENSIVITY))) 
    { 


      if(edgechanged) // Determine next turning point type 
      { 
        if(buffI[i] > buffI[i+1])   // I(t): New edge is falling 
          nextismax = false;        // Look for minimum 
        else                        // I(t): New edge is rising 
          nextismax = true;         // Look for maximum 
        edgechanged = false; 
      } 


      if (nextismax) 
      { 
        if (buffI[i] > buffI[i + 1])    // Waiting for maximum 
        { 
          if (buffQ[i] > buffQ[i + 1])  // ... meets falling edge Q(t) 
              indicator++;  
          else if (buffQ[i] < buffQ[i + 1]) // ... meets rising edge Q(t) 
              indicator--;  
          edgechanged = true; // Prepare for determine next edge I(t) 
        } 
      } 
      else 
      { 
        if (buffI[i] < buffI[i + 1])   // Waiting for minimum 
        { 
          if (buffQ[i] > buffQ[i + 1]) // ... meets falling edge Q(t) 
              indicator--;       
          else if (buffQ[i] < buffQ[i + 1]) // ... meets rising edge Q(t) 
              indicator++; 
          edgechanged = true;   // Prepare for next edge I(t) 
        } 
      } 
    } 
  } 


  if (indicator > 0) 
    directionRet = 1; 
  else if (indicator < 0) 
    directionRet = -1; 


  return directionRet; 
}