How to Build a DIY Walkthrough Detector Using Arduino UNO

#include <Arduino_LED_Matrix.h>

const int sensorDig = 2;  // Digital pin 2 for sensor input (interrupt pin)

unsigned int updateRate = 100;    // Sensor update rate in ms
unsigned int measureTime = 100;   // Sensor measure time in ms

volatile unsigned int intEnable = 0;      // Interrupt counter enable flag
volatile unsigned long sensorDigCnt = 0;  // Count of sensor signal changes
unsigned long prevMillis = 0;              // For timing updates

float base_line = 0.0;                // Moving average baseline
const float alpha = 0.1;              // Smoothing factor for baseline
const float base_line_change = 10.0; // Threshold for significant change
const int N = 10;                     // Number of samples for peak event duration

int peakSamplesCount = 0;     // Samples counted during peak event
bool inPeakEvent = false;     // Flag: tracking a peak event?
float peakValue = 0.0;        // Maximum deviation recorded during peak event

int state = 0;  // State machine variable

// LED matrix setup
ArduinoLEDMatrix matrix;

const int matrixWidth = 12;
const int matrixHeight = 8;

// Alert sign bitmap 10x7 pixels (largest fitting design)
// A large exclamation mark ! with border
const uint8_t alertWidth = 10;
const uint8_t alertHeight = 7;
const uint8_t alertBitmap[alertHeight] = {
  0b0000110000,  // border top
  0b0000110000,  // |    !   |
  0b0000110000,  // |    !   |
  0b0000110000,  // |    !   |
  0b0000000000,  // |    !   |
  0b0000110000,  // |    !   |
  0b0000110000   // border bottom
};

uint8_t frame[matrixHeight][matrixWidth];

void clearFrame() {
  for (int y = 0; y < matrixHeight; y++) {
    for (int x = 0; x < matrixWidth; x++) {
      frame[y][x] = 0;
    }
  }
}

void drawAlert(int xPos, int yPos) {
  clearFrame();
  for (int row = 0; row < alertHeight; row++) {
    for (int col = 0; col < alertWidth; col++) {
      bool pixelOn = alertBitmap[row] & (1 << (alertWidth - 1 - col));
      int x = xPos + col;
      int y = yPos + row;
      if (pixelOn && x >= 0 && x < matrixWidth && y >= 0 && y < matrixHeight) {
        frame[y][x] = 1;
      }
    }
  }
  matrix.renderBitmap(frame, matrixHeight, matrixWidth);
}

void setup() {
  Serial.begin(115200);
  pinMode(sensorDig, INPUT);
  attachInterrupt(digitalPinToInterrupt(sensorDig), sensorDigHandler, RISING);

  matrix.begin();
  matrix.clear();

  // Initialize baseline with first measurement
  sensorDigCnt = 0;
  intEnable = 1;
  delay(measureTime);
  intEnable = 0;
  base_line = sensorDigCnt;
  Serial.print("Initial baseline: ");
  Serial.println(base_line);

  prevMillis = millis();
}

void loop() {
  unsigned long currMillis = millis();

  switch (state) {
    case 1:
      // Update baseline (moving average)
      base_line = alpha * sensorDigCnt + (1.0 - alpha) * base_line;

      // Calculate deviation from baseline
      float diff = sensorDigCnt - base_line;

      if (!inPeakEvent) {
        // Not currently tracking a peak event
        if (abs(diff) > base_line_change) {
          inPeakEvent = true;
          peakSamplesCount = 1;
          peakValue = diff;
        }
      } else {
        // Tracking peak event
        peakSamplesCount++;
        if (abs(diff) > abs(peakValue)) {
          peakValue = diff;
        }

        // End peak detection when signal returns near baseline or max samples reached
        if (abs(diff) <= base_line_change || peakSamplesCount > N) {
          Serial.print("Peak detected: ");
          Serial.println(peakValue);
          inPeakEvent = false;
          peakSamplesCount = 0;
          peakValue = 0.0;

          // Display alert sign centered on the matrix
          drawAlert((matrixWidth - alertWidth) / 2, (matrixHeight - alertHeight) / 2);
          delay(2000);   // Display alert for 2 seconds
          matrix.clear();
        }
      }

      Serial.print("Sensor= ");
      Serial.print(sensorDigCnt);
      Serial.print(" Baseline= ");
      Serial.println(base_line);

      state = 0;
      break;
  }

  if (currMillis - prevMillis >= updateRate) {
    sensorDigCnt = 0;
    prevMillis = currMillis;
    intEnable = 1;
    delay(measureTime);
    intEnable = 0;
    state = 1;
  }
}

// Interrupt handler increments counter on rising edge
void sensorDigHandler() {
  if (intEnable == 1) {
    sensorDigCnt++;
  }
}