How to use ZP01 sensor to test air quality

				
					// ====================== Hardware Pin Definitions ======================
// LCD1602 pins (RS, EN, D4, D5, D6, D7)
LiquidCrystal lcd(7, 8, 9, 10, 11, 12);
// ZP01 odor sensor pins
const int PIN_ZP01_A = 2;
const int PIN_ZP01_B = 3;
// Alarm output pins
const int PIN_BUZZER = 4;
const int LED_LIGHT = 5;   // Green LED (light pollution)
const int LED_MODERATE = 6;// Yellow LED (moderate pollution)
const int LED_SEVERE = 13; // Red LED (severe pollution)
// Buttons (pull-up input, trigger on LOW level)
const int KEY_THRESHOLD = A0; // Adjust alarm threshold
const int KEY_MUTE = A1;      // Mute alarm

// ====================== Global Variables ======================
int odorGrade = 0;          // Current odor grade (0-3: clean to severe)
int alarmThreshold = 1;     // Alarm threshold (1=light+, 2=moderate+, 3=severe only)
bool isMute = false;        // Mute status (true = buzzer off)
bool lastMuteState = false; // Last mute state (prevent repeated trigger)
unsigned long lastKeyTime = 0; // Key debounce timestamp
const int DEBOUNCE_DELAY = 20; // Debounce delay (ms)

// ====================== Function Declarations ======================
void readOdorGrade();       // Read ZP01 signal and judge odor grade
void updateLED();           // Control LED indicators based on odor grade
void updateBuzzer();        // Control buzzer based on grade, threshold and mute state
void handleKeyInput();      // Process button input (debounce + function logic)
void updateLCD();           // Update LCD display (no flicker)
void printSerialLog();      // Output formatted log to serial monitor

void setup() {
  // Initialize pin modes
  pinMode(PIN_ZP01_A, INPUT);
  pinMode(PIN_ZP01_B, INPUT);
  pinMode(PIN_BUZZER, OUTPUT);
  pinMode(LED_LIGHT, OUTPUT);
  pinMode(LED_MODERATE, OUTPUT);
  pinMode(LED_SEVERE, OUTPUT);
  pinMode(KEY_THRESHOLD, INPUT_PULLUP); // Enable internal pull-up resistor
  pinMode(KEY_MUTE, INPUT_PULLUP);

  // Initialize LCD
  lcd.begin(16, 2);
  lcd.print("ZP01 Detector");
  delay(1000);
  lcd.clear();
  lcd.print("Threshold: ");
  lcd.print(alarmThreshold);
  delay(500);
  lcd.clear();

  // Initialize serial monitor (9600 baud rate)
  Serial.begin(9600);
  Serial.println("=== ZP01 Odor Detector Start ===");
  Serial.print("Initial Alarm Threshold: ");
  Serial.println(alarmThreshold);

  // Turn off all outputs by default
  digitalWrite(PIN_BUZZER, HIGH);
  digitalWrite(LED_LIGHT, LOW);
  digitalWrite(LED_MODERATE, LOW);
  digitalWrite(LED_SEVERE, LOW);
}

void loop() {
  readOdorGrade();    // Get current odor grade
  handleKeyInput();   // Check button presses
  updateLED();        // Update LED status
  updateBuzzer();     // Update buzzer status
  updateLCD();        // Refresh LCD if status changed
  printSerialLog();   // Output log to serial
  delay(200);         // Main loop interval (avoid frequent refresh)
}

// Read ZP01 A/B pin levels and determine odor grade
// 0 = Clean, 1 = Light pollution, 2 = Moderate pollution, 3 = Severe pollution
void readOdorGrade() {
  int valA = digitalRead(PIN_ZP01_A);
  int valB = digitalRead(PIN_ZP01_B);

  if (valA == LOW && valB == LOW) {
    odorGrade = 0;
  } else if (valA == LOW && valB == HIGH) {
    odorGrade = 1;
  } else if (valA == HIGH && valB == LOW) {
    odorGrade = 2;
  } else {
    odorGrade = 3;
  }
}

// Control LED indicators: green for light, yellow for moderate, all on for severe
void updateLED() {
  // Turn off all LEDs first to avoid residual light
  digitalWrite(LED_LIGHT, LOW);
  digitalWrite(LED_MODERATE, LOW);
  digitalWrite(LED_SEVERE, LOW);

  switch (odorGrade) {
    case 1:
      digitalWrite(LED_LIGHT, HIGH); // Green LED on for light pollution
      break;
    case 2:
      digitalWrite(LED_MODERATE, HIGH); // Yellow LED on for moderate pollution
      break;
    case 3:
      // All LEDs on for severe pollution
      digitalWrite(LED_LIGHT, HIGH);
      digitalWrite(LED_MODERATE, HIGH);
      digitalWrite(LED_SEVERE, HIGH);
      break;
    default: // Grade 0 (clean), all LEDs off
      break;
  }
}

// Control buzzer: different beep frequency for different grades (if not muted)
void updateBuzzer() {
  // Trigger buzzer only if grade >= threshold and not muted
  if (odorGrade >= alarmThreshold && !isMute) {
    // Different beep frequency based on odor grade
    switch (odorGrade) {
      case 1: // Light pollution: beep once per second (200ms on, 800ms off)
        digitalWrite(PIN_BUZZER, LOW);
        delay(200);
        digitalWrite(PIN_BUZZER, HIGH);
        delay(800);
        break;
      case 2: // Moderate pollution: beep twice per second (100ms on, 100ms off)
        digitalWrite(PIN_BUZZER, LOW);
        delay(100);
        digitalWrite(PIN_BUZZER, HIGH);
        delay(100);
        break;
      case 3: // Severe pollution: buzzer on continuously
        digitalWrite(PIN_BUZZER, LOW);
        break;
    }
  } else {
    digitalWrite(PIN_BUZZER, HIGH); // Turn off buzzer
    // Auto cancel mute if grade drops below threshold
    if (odorGrade < alarmThreshold) {
      isMute = false;
    }
  }
}

// Process button input with debounce to avoid false triggers
void handleKeyInput() {
  unsigned long currentTime = millis();
  // Button 1: Adjust alarm threshold (cycle 1→2→3→1)
  if (digitalRead(KEY_THRESHOLD) == LOW && currentTime - lastKeyTime > DEBOUNCE_DELAY) {
    alarmThreshold++;
    if (alarmThreshold > 3) alarmThreshold = 1;
    lastKeyTime = currentTime;
    Serial.print("Alarm Threshold Updated: ");
    Serial.println(alarmThreshold);
    delay(100); // Short delay to prevent continuous press
  }
  // Button 2: Toggle mute status
  if (digitalRead(KEY_MUTE) == LOW && currentTime - lastKeyTime > DEBOUNCE_DELAY) {
    isMute = !isMute;
    lastKeyTime = currentTime;
    Serial.print("Mute State: ");
    Serial.println(isMute ? "ON" : "OFF");
    delay(100);
  }
}

// Update LCD only when status changes (no flicker)
void updateLCD() {
  static int lastGrade = -1;
  static int lastThreshold = -1;
  static bool lastMute = false;

  // Refresh LCD only if grade/threshold/mute status changes
  if (odorGrade != lastGrade || alarmThreshold != lastThreshold || isMute != lastMute) {
    lcd.clear();
    // First line: Odor grade + mute status
    lcd.setCursor(0, 0);
    lcd.print("Odor: ");
    switch (odorGrade) {
      case 0: lcd.print("Clean  "); break;
      case 1: lcd.print("Light  "); break;
      case 2: lcd.print("Moderate"); break;
      case 3: lcd.print("Severe "); break;
    }
    lcd.print(isMute ? "(Mute)" : "      ");

    // Second line: Alarm threshold
    lcd.setCursor(0, 1);
    lcd.print("Thresh: ");
    lcd.print(alarmThreshold);
    lcd.print(" (Lv");
    lcd.print(alarmThreshold);
    lcd.print("+)");

    // Update last status to compare next time
    lastGrade = odorGrade;
    lastThreshold = alarmThreshold;
    lastMute = isMute;
  }
}

// Output formatted serial log (once per second to avoid spam)
void printSerialLog() {
  static unsigned long lastLogTime = 0;
  // Output log every 1 second
  if (millis() - lastLogTime > 1000) {
    Serial.print("[");
    Serial.print(millis() / 1000); // Elapsed time in seconds
    Serial.print("s] Odor Grade: ");
    Serial.print(odorGrade);
    Serial.print(" | Alarm Thresh: ");
    Serial.print(alarmThreshold);
    Serial.print(" | Mute: ");
    Serial.println(isMute ? "YES" : "NO");
    lastLogTime = millis();
  }
}