Tiny Size, Big Power: QRE1113 IR Sensor for Industrial Counting & Positioning

				
					/*
 * Auto Induction Faucet - Stop Immediately When Hand Leaves Version
 * Function: Water flows when hand present, stops immediately when hand leaves
 */

// Pin Definitions
const int sensorPin = A0;  // QRE1113 OUT to A0
const int relayPin = 3;    // Relay IN to D3
const int ledPin = 13;     // Onboard LED

// Key Parameters
int triggerDelta = 50;     // Trigger difference (default 50)
int baseline = 0;          // Environment baseline value
unsigned long handTime = 0;
bool relayOn = false;
bool handDetected = false;
bool coolingDown = false;  // Cooldown protection flag
unsigned long cooldownStart = 0;

// Relay Trigger Mode
const bool RELAY_HIGH_TRIGGER = true;  // Modify according to your relay type

// Timing Parameters
const unsigned long COOLDOWN_TIME = 1000;      // Cooldown time 1 second
const unsigned long SAFETY_TIMEOUT = 30000;    // Safety timeout 30 seconds
const unsigned long MIN_ON_TIME = 200;         // Minimum on time 0.2 seconds

void setup() {
  Serial.begin(9600);
  pinMode(sensorPin, INPUT);
  pinMode(relayPin, OUTPUT);
  pinMode(ledPin, OUTPUT);
  
  // Initially off
  setRelay(false);
  digitalWrite(ledPin, LOW);
  
  Serial.println("Auto Induction Faucet - Stop When Hand Leaves Version");
  Serial.println("======================================================");
  
  // Calibration
  calibrate();
  
  Serial.println("\nSystem Ready! Water flows when hand present, stops when hand leaves");
  Serial.println("======================================================");
}

void loop() {
  unsigned long now = millis();
  
  // Read sensor
  int sensorValue = readFiltered();
  int delta = baseline - sensorValue;
  
  // Detect hand
  bool newHand = (delta > triggerDelta && sensorValue > 10);
  
  // Control logic
  if (newHand && !handDetected) {
    // Hand just entered
    handDetected = true;
    handTime = now;
    
    if (!coolingDown && !relayOn) {
      startWater();
      Serial.print("Hand detected! Δ=");
      Serial.println(delta);
    }
  }
  else if (!newHand && handDetected) {
    // Hand left
    handDetected = false;
    
    if (relayOn) {
      // Hand left, check minimum on time
      if (now - handTime >= MIN_ON_TIME) {
        stopWater();
        Serial.println("Hand left, water stopped immediately");
      } else {
        // Minimum time not reached, wait a bit
        delay(MIN_ON_TIME - (now - handTime));
        if (relayOn) {  // Double check
          stopWater();
          Serial.println("Hand left, minimum time reached, water stopped");
        }
      }
    }
  }
  
  // Hand still present
  if (handDetected && relayOn) {
    // Hand still there, update time
    handTime = now;
  }
  
  // Safety timeout check
  if (relayOn && (now - handTime > SAFETY_TIMEOUT)) {
    setRelay(false);
    relayOn = false;
    coolingDown = true;
    cooldownStart = now;
    Serial.println("Safety timeout! Forced water stop!");
  }
  
  // Cooldown protection check
  if (coolingDown && (now - cooldownStart >= COOLDOWN_TIME)) {
    coolingDown = false;
  }
  
  // Auto-update baseline
  updateBaseline(sensorValue, now);
  
  // Display status
  static unsigned long lastPrint = 0;
  if (now - lastPrint > 500) {
    printStatus(sensorValue, delta, now);
    lastPrint = now;
  }
  
  // Serial commands
  if (Serial.available()) {
    handleCommand(now);
  }
  
  delay(20);
}

// ========== Helper Functions ==========

int readFiltered() {
  int sum = 0;
  for (int i = 0; i < 4; i++) {
    sum += analogRead(sensorPin);
    delay(1);
  }
  return sum / 4;
}

void calibrate() {
  Serial.println("Calibrating... Keep clear of sensor");
  long sum = 0;
  for (int i = 0; i < 20; i++) {
    sum += analogRead(sensorPin);
    delay(50);
  }
  baseline = sum / 20;
  Serial.print("Baseline: ");
  Serial.println(baseline);
}

void updateBaseline(int sensorValue, unsigned long now) {
  static unsigned long lastUpdate = 0;
  if (now - lastUpdate > 2000 && !handDetected) {
    if (abs(baseline - sensorValue) < 20) {
      baseline = (baseline * 9 + sensorValue) / 10;
    }
    lastUpdate = now;
  }
}

void startWater() {
  if (!relayOn) {
    setRelay(true);
    relayOn = true;
    digitalWrite(ledPin, HIGH);
  }
}

void stopWater() {
  if (relayOn) {
    setRelay(false);
    relayOn = false;
    coolingDown = true;
    cooldownStart = millis();
    digitalWrite(ledPin, LOW);
  }
}

void setRelay(bool state) {
  if (RELAY_HIGH_TRIGGER) {
    digitalWrite(relayPin, state ? HIGH : LOW);
  } else {
    digitalWrite(relayPin, state ? LOW : HIGH);
  }
}

void printStatus(int sensorValue, int delta, unsigned long now) {
  Serial.print("Sensor: ");
  Serial.print(sensorValue);
  Serial.print(" | Baseline: ");
  Serial.print(baseline);
  Serial.print(" | Δ: ");
  Serial.print(delta);
  Serial.print(" | Threshold: ");
  Serial.print(triggerDelta);
  Serial.print(" | Status: ");
  
  if (coolingDown) {
    Serial.print("Cooling");
  } else if (relayOn) {
    unsigned long flowTime = (now - handTime) / 1000;
    Serial.print("Flowing(");
    Serial.print(flowTime);
    Serial.print("s)");
  } else if (handDetected) {
    Serial.print("Hand detected");
  } else {
    Serial.print("Standby");
  }
  
  Serial.println();
}

void handleCommand(unsigned long now) {
  char cmd = Serial.read();
  
  switch(cmd) {
    case '1':
      if (!coolingDown) {
        startWater();
        handDetected = true;  // Simulate hand presence
        handTime = now;
        Serial.println("Manual: Water ON");
      } else {
        Serial.println("Cooling down");
      }
      break;
      
    case '0':
      stopWater();
      handDetected = false;
      Serial.println("Manual: Water OFF");
      break;
      
    case '+':
      triggerDelta = max(20, triggerDelta - 10);
      Serial.print("More sensitive: Δ>");
      Serial.println(triggerDelta);
      break;
      
    case '-':
      triggerDelta = min(150, triggerDelta + 10);
      Serial.print("More stable: Δ>");
      Serial.println(triggerDelta);
      break;
      
    case 'c':
      if (!relayOn) {
        calibrate();
      } else {
        Serial.println("Turn off water first before calibration");
      }
      break;
      
    case 'h':
      Serial.println("Commands: 1=ON, 0=OFF, +=Sensitive, -=Stable, c=Calibrate, h=Help");
      break;
  }
}