Arduino Heart Rate Sensor Circuit
                
    Arduino Uno                    PPG Sensor Module               Display & Output
    ┌─────────────┐               ┌─────────────────┐             ┌──────────────┐
    │             │               │                 │             │              │
    │         5V  │ ──────────────│ VCC             │             │   OLED       │
    │         GND │ ──────────────│ GND             │             │   Display    │
    │         A0  │ ◄─────────────│ Signal Out      │             │   128x64     │
    │         D2  │ ──────────────│ LED Control     │             │              │
    │             │               │                 │             │              │
    │         SCL │ ──────────────┼─────────────────┼─────────────│ SCL          │
    │         SDA │ ──────────────┼─────────────────┼─────────────│ SDA          │
    │             │               │                 │             │              │
    │         D13 │ ──────────────┼─────────────────┼─────────────│ Status LED   │
    │             │               │                 │             │              │
    └─────────────┘               └─────────────────┘             └──────────────┘
            │                              │                              │
            │                              │                              │
            ▼                              ▼                              ▼
    ┌─────────────┐               ┌─────────────────┐             ┌──────────────┐
    │   USB/PC    │               │  Finger Clip    │             │   Buzzer     │
    │ (Serial Mon)│               │   Sensor        │             │  (Optional)  │
    └─────────────┘               └─────────────────┘             └──────────────┘

Components Used:
- Arduino Uno R3
- PPG Sensor (LED + Photodiode)
- OLED Display SSD1306
- Resistors: 220Ω, 10kΩ
- Capacitors: 100nF, 10µF
- Operational Amplifier (LM358)

/*
  Arduino Heart Rate Sensor - One Hertz Challenge 2025 Winner
  Uses PPG (Photoplethysmography) technique for real-time heart rate monitoring
  
  Hardware Requirements:
  - Arduino Uno/Nano
  - PPG Sensor Module (LED + Photodiode)
  - OLED Display SSD1306
  - Operational Amplifier for signal conditioning
*/

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

// Display configuration
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
#define OLED_RESET -1
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

// Pin definitions
#define PPG_SENSOR_PIN A0    // Analog input from PPG sensor
#define LED_CONTROL_PIN 2    // Control pin for PPG LED
#define STATUS_LED_PIN 13    // Status indicator LED

// Heart rate calculation variables
const int SAMPLE_RATE = 100;           // 100 Hz sampling rate
const int BUFFER_SIZE = 500;           // 5 seconds of data
const int MIN_BPM = 40;                // Minimum valid heart rate
const int MAX_BPM = 200;               // Maximum valid heart rate

int sensorBuffer[BUFFER_SIZE];         // Circular buffer for sensor data
int bufferIndex = 0;                   // Current buffer position
unsigned long lastSampleTime = 0;      // Timing for sampling
unsigned long lastBeatTime = 0;        // Timing for beat detection
int currentBPM = 0;                    // Current heart rate
bool validReading = false;             // Flag for valid sensor reading

// Signal processing variables
int baseline = 512;                    // DC baseline (mid-point of ADC)
int threshold = 20;                    // Beat detection threshold
int lastPeakValue = 0;                 // Last detected peak value
bool beatDetected = false;             // Beat detection flag

// Moving average filter
const int FILTER_SIZE = 5;
int filterBuffer[FILTER_SIZE];
int filterIndex = 0;

void setup() {
  Serial.begin(115200);
  
  // Initialize pins
  pinMode(LED_CONTROL_PIN, OUTPUT);
  pinMode(STATUS_LED_PIN, OUTPUT);
  
  // Turn on PPG LED
  digitalWrite(LED_CONTROL_PIN, HIGH);
  
  // Initialize OLED display
  if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
    Serial.println(F("SSD1306 allocation failed"));
    for (;;);
  }
  
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(0, 0);
  display.println(F("Heart Rate Monitor"));
  display.println(F("One Hertz Challenge"));
  display.println(F("Initializing..."));
  display.display();
  
  // Initialize buffers
  for (int i = 0; i < BUFFER_SIZE; i++) {
    sensorBuffer[i] = 0;
  }
  for (int i = 0; i < FILTER_SIZE; i++) {
    filterBuffer[i] = 0;
  }
  
  // Calibration period
  Serial.println("Calibrating sensor...");
  delay(2000);
  calibrateSensor();
  
  Serial.println("Heart Rate Monitor Ready!");
  Serial.println("Place finger on sensor...");
}

void loop() {
  unsigned long currentTime = millis();
  
  // Sample at 100 Hz (every 10ms)
  if (currentTime - lastSampleTime >= 10) {
    lastSampleTime = currentTime;
    
    // Read sensor value
    int rawValue = analogRead(PPG_SENSOR_PIN);
    
    // Apply moving average filter
    int filteredValue = applyMovingAverage(rawValue);
    
    // Store in circular buffer
    sensorBuffer[bufferIndex] = filteredValue;
    bufferIndex = (bufferIndex + 1) % BUFFER_SIZE;
    
    // Detect heartbeat
    if (detectBeat(filteredValue)) {
      calculateHeartRate(currentTime);
      digitalWrite(STATUS_LED_PIN, HIGH);
      delay(50);  // Brief LED flash
      digitalWrite(STATUS_LED_PIN, LOW);
    }
    
    // Update display every 100ms
    static unsigned long lastDisplayUpdate = 0;
    if (currentTime - lastDisplayUpdate >= 100) {
      lastDisplayUpdate = currentTime;
      updateDisplay(filteredValue);
    }
    
    // Send data to serial monitor
    Serial.print(rawValue);
    Serial.print(",");
    Serial.print(filteredValue);
    Serial.print(",");
    Serial.print(currentBPM);
    Serial.print(",");
    Serial.println(beatDetected ? 1 : 0);
    
    beatDetected = false;  // Reset beat flag
  }
}

void calibrateSensor() {
  long sum = 0;
  int samples = 200;
  
  for (int i = 0; i < samples; i++) {
    sum += analogRead(PPG_SENSOR_PIN);
    delay(10);
  }
  
  baseline = sum / samples;
  threshold = baseline * 0.05;  // 5% of baseline as threshold
  
  Serial.print("Baseline: ");
  Serial.print(baseline);
  Serial.print(", Threshold: ");
  Serial.println(threshold);
}

int applyMovingAverage(int newValue) {
  filterBuffer[filterIndex] = newValue;
  filterIndex = (filterIndex + 1) % FILTER_SIZE;
  
  long sum = 0;
  for (int i = 0; i < FILTER_SIZE; i++) {
    sum += filterBuffer[i];
  }
  
  return sum / FILTER_SIZE;
}

bool detectBeat(int currentValue) {
  static int lastValue = 0;
  static bool risingEdge = false;
  static unsigned long lastBeatDetection = 0;
  
  // Minimum time between beats (300ms = 200 BPM max)
  if (millis() - lastBeatDetection < 300) {
    lastValue = currentValue;
    return false;
  }
  
  // Detect rising edge
  if (currentValue > lastValue && !risingEdge) {
    risingEdge = true;
  }
  
  // Detect peak (falling edge after rising)
  if (currentValue < lastValue && risingEdge) {
    if (lastValue > (baseline + threshold)) {
      risingEdge = false;
      lastBeatDetection = millis();
      lastPeakValue = lastValue;
      beatDetected = true;
      return true;
    }
    risingEdge = false;
  }
  
  lastValue = currentValue;
  return false;
}

void calculateHeartRate(unsigned long currentTime) {
  static unsigned long beatTimes[10];  // Store last 10 beat times
  static int beatIndex = 0;
  static int beatCount = 0;
  
  // Store current beat time
  beatTimes[beatIndex] = currentTime;
  beatIndex = (beatIndex + 1) % 10;
  
  if (beatCount < 10) {
    beatCount++;
  }
  
  // Calculate average interval from last few beats
  if (beatCount >= 3) {
    unsigned long totalInterval = 0;
    int intervals = 0;
    
    for (int i = 1; i < beatCount; i++) {
      int prevIndex = (beatIndex - i - 1 + 10) % 10;
      int currIndex = (beatIndex - i + 10) % 10;
      
      if (beatTimes[currIndex] > beatTimes[prevIndex]) {
        totalInterval += (beatTimes[currIndex] - beatTimes[prevIndex]);
        intervals++;
      }
    }
    
    if (intervals > 0) {
      unsigned long avgInterval = totalInterval / intervals;
      int calculatedBPM = 60000 / avgInterval;  // Convert to BPM
      
      // Validate BPM range
      if (calculatedBPM >= MIN_BPM && calculatedBPM <= MAX_BPM) {
        currentBPM = calculatedBPM;
        validReading = true;
      }
    }
  }
}

void updateDisplay(int sensorValue) {
  display.clearDisplay();
  
  // Title
  display.setTextSize(1);
  display.setCursor(0, 0);
  display.println(F("Heart Rate Monitor"));
  
  // Current BPM
  display.setTextSize(2);
  display.setCursor(0, 16);
  if (validReading) {
    display.print(currentBPM);
    display.println(F(" BPM"));
  } else {
    display.println(F("-- BPM"));
  }
  
  // Status
  display.setTextSize(1);
  display.setCursor(0, 40);
  if (validReading) {
    display.println(F("Status: OK"));
  } else {
    display.println(F("Place finger..."));
  }
  
  // Signal strength bar
  display.setCursor(0, 56);
  display.print(F("Signal: "));
  int signalStrength = map(abs(sensorValue - baseline), 0, 100, 0, 10);
  for (int i = 0; i < signalStrength; i++) {
    display.print(F("|"));
  }
  
  display.display();
}

// Additional functions for data logging and analysis
void logDataToSerial() {
  // Send formatted data for external analysis
  Serial.print(F("BPM:"));
  Serial.print(currentBPM);
  Serial.print(F(",Valid:"));
  Serial.print(validReading ? 1 : 0);
  Serial.print(F(",Baseline:"));
  Serial.print(baseline);
  Serial.print(F(",Peak:"));
  Serial.println(lastPeakValue);
}

// Function to detect sensor placement
bool isSensorPlaced() {
  int variance = 0;
  int mean = 0;
  
  // Calculate variance of recent samples
  for (int i = 0; i < 50; i++) {
    int index = (bufferIndex - i + BUFFER_SIZE) % BUFFER_SIZE;
    mean += sensorBuffer[index];
  }
  mean /= 50;
  
  for (int i = 0; i < 50; i++) {
    int index = (bufferIndex - i + BUFFER_SIZE) % BUFFER_SIZE;
    int diff = sensorBuffer[index] - mean;
    variance += diff * diff;
  }
  variance /= 50;
  
  // If variance is too low, sensor is not properly placed
  return variance > 10;
}