Practical case: ESP32 Secure Access Panel

#include <Arduino.h>

// --------------------------------------------------------
// Pin Definitions
// --------------------------------------------------------
const int TOUCH_PAD_1 = 4;  // GPIO 4  (Touch 0)
const int TOUCH_PAD_2 = 2;  // GPIO 2  (Touch 2)
const int TOUCH_PAD_3 = 15; // GPIO 15 (Touch 3)
const int LED_PIN     = 21; // Status LED
const int BUZZER_PIN  = 22; // Piezo Buzzer

// --------------------------------------------------------
// System Configuration & Thresholds
// --------------------------------------------------------
// A typical untouched ESP32 pin reads ~50-80. 
// A touched pin drops below 20. Adjust this if your pads differ.
const int TOUCH_THRESHOLD = 30; 

// Access Control Sequence Configuration
const int SEQUENCE_LENGTH = 4;
const int SECRET_PIN[SEQUENCE_LENGTH] = {1, 2, 3, 2}; // The correct access code
int inputSequence[SEQUENCE_LENGTH];
int inputIndex = 0;

// State Machine Variables
enum SystemState { LOCKED, INPUTTING, UNLOCKED };
SystemState currentState = LOCKED;

unsigned long unlockTimestamp = 0;
const unsigned long UNLOCK_DURATION = 5000; // Keep unlocked for 5 seconds

// Debouncing Variables
bool pad1_wasTouched = false;
bool pad2_wasTouched = false;
bool pad3_wasTouched = false;

// --------------------------------------------------------
// Function Prototypes
// --------------------------------------------------------
void processTouch();
void handleKeyPress(int keyNumber);
void evaluateSequence();
void triggerSuccess();
void triggerFailure();
void lockSystem();
void playTone(int frequency, int duration);

// --------------------------------------------------------
// Setup
// --------------------------------------------------------
void setup() {
    Serial.begin(115200);
    while (!Serial) { delay(10); } // Wait for serial connection

    Serial.println("\n--- Capacitive Touch Access Panel Initialized ---");

    pinMode(LED_PIN, OUTPUT);
    pinMode(BUZZER_PIN, OUTPUT);

    lockSystem(); // Ensure system starts in locked state
}

// --------------------------------------------------------
// Main Loop
// --------------------------------------------------------
void loop() {
    // Handle state timeouts (Auto-lock)
    if (currentState == UNLOCKED) {
        if (millis() - unlockTimestamp >= UNLOCK_DURATION) {
            Serial.println("Auto-locking system due to timeout.");
            lockSystem();
        }
    } else {
        // Only process touch inputs if the system is not currently unlocked
        processTouch();
    }

    // Small delay to yield to the underlying RTOS
    delay(10); 
}

// --------------------------------------------------------
// Touch Processing & Debouncing
// --------------------------------------------------------
void processTouch() {
    // Read raw capacitance values
    int val1 = touchRead(TOUCH_PAD_1);
    int val2 = touchRead(TOUCH_PAD_2);
    int val3 = touchRead(TOUCH_PAD_3);

    // Evaluate Pad 1
    bool pad1_isTouched = (val1 < TOUCH_THRESHOLD);
    if (pad1_isTouched && !pad1_wasTouched) {
        handleKeyPress(1);
    }
    pad1_wasTouched = pad1_isTouched;

    // Evaluate Pad 2
    bool pad2_isTouched = (val2 < TOUCH_THRESHOLD);
    if (pad2_isTouched && !pad2_wasTouched) {
        handleKeyPress(2);
    }
    pad2_wasTouched = pad2_isTouched;

    // Evaluate Pad 3
    bool pad3_isTouched = (val3 < TOUCH_THRESHOLD);
    if (pad3_isTouched && !pad3_wasTouched) {
        handleKeyPress(3);
    }
    pad3_wasTouched = pad3_isTouched;
}

// --------------------------------------------------------
// Logic Handling
// --------------------------------------------------------
void handleKeyPress(int keyNumber) {
    // Provide immediate acoustic feedback
    playTone(1000, 100); 

    Serial.print("Key Pressed: ");
    Serial.println(keyNumber);

    // Update state
    currentState = INPUTTING;

    // Store the input
    inputSequence[inputIndex] = keyNumber;
    inputIndex++;

    // Check if we have collected enough inputs
    if (inputIndex >= SEQUENCE_LENGTH) {
        evaluateSequence();
    }
}

void evaluateSequence() {
    Serial.println("Evaluating entered sequence...");
    bool isMatch = true;

    for (int i = 0; i < SEQUENCE_LENGTH; i++) {
        if (inputSequence[i] != SECRET_PIN[i]) {
            isMatch = false;
            break;
        }
    }

    if (isMatch) {
        triggerSuccess();
    } else {
        triggerFailure();
    }

    // Reset input index for the next attempt
    inputIndex = 0;
}

// --------------------------------------------------------
// Output & Feedback Generators
// --------------------------------------------------------
void triggerSuccess() {
    Serial.println("ACCESS GRANTED.");
    currentState = UNLOCKED;
    unlockTimestamp = millis();

    // Visual indicator: LED ON
    digitalWrite(LED_PIN, HIGH);

    // Acoustic indicator: Success Melody
    playTone(1200, 150);
    delay(50);
    playTone(1500, 150);
    delay(50);
    playTone(2000, 300);
}

void triggerFailure() {
    Serial.println("ACCESS DENIED. Incorrect PIN.");

    // Acoustic indicator: Error Tone
    playTone(300, 400);
    delay(100);
    playTone(300, 400);

    // Return to locked state immediately
    lockSystem();
}

void lockSystem() {
    currentState = LOCKED;
    inputIndex = 0; // Clear any partial inputs
    digitalWrite(LED_PIN, LOW); // LED OFF indicates locked
    Serial.println("System LOCKED. Ready for input.");
}

// Helper function for the buzzer
void playTone(int frequency, int duration) {
    tone(BUZZER_PIN, frequency, duration);
    // The tone function in Arduino is non-blocking, but for this HMI 
    // we want the beep to complete before proceeding in feedback sequences.
    delay(duration); 
}