ESP32-S3 – TTP223 Touch Sensor Code

This code detects touch from the TTP223 sensor (pin 2) and toggles a white RGB LED (pins 4, 5, 6).

🧩 Code Breakdown and Explanation

1. #define Section – Pin Configuration

// Define the pin connected to the touch sensor's output
#define TOUCH_PIN 2

// Define the pins connected to the RGB LED cathodes
#define RED_PIN 4
#define GREEN_PIN 5
#define BLUE_PIN 6

This section sets up constant names for each pin used. By using #define, the code becomes more readable and maintainable. If the hardware design changes, pin numbers can be updated here without modifying the logic.

2. Variable Declaration – State Control

// Boolean flag to track the current LED state (ON or OFF)
bool ledState = false;

This boolean variable stores the current state of the LED. It prevents the LED from toggling repeatedly during one single touch event, ensuring stable behavior.

3. setup() Function – System Initialization

void setup() {
    Serial.begin(115200);                  // Start serial communication for debugging
    pinMode(RED_PIN, OUTPUT);              // Set Red channel as output
    pinMode(GREEN_PIN, OUTPUT);            // Set Green channel as output
    pinMode(BLUE_PIN, OUTPUT);             // Set Blue channel as output
    pinMode(TOUCH_PIN, INPUT);             // Set the sensor pin as input

    digitalWrite(RED_PIN, LOW);            // Ensure Red LED is OFF at startup
    digitalWrite(GREEN_PIN, LOW);          // Ensure Green LED is OFF
    digitalWrite(BLUE_PIN, LOW);           // Ensure Blue LED is OFF
}

This function runs once when the ESP32-S3 starts. It initializes serial communication for monitoring, sets up the RGB pins as digital outputs, and configures the touch sensor pin as an input. All LED channels are turned off initially to avoid unexpected behavior at power-up.

4. loop() Function – Continuous Execution

void loop() {
    int touchValue = digitalRead(TOUCH_PIN);   // Read current state from TTP223 sensor

    Serial.print("Touch value: ");             // Print label
    Serial.println(touchValue);                // Display raw sensor output (0 or 1)

    if (touchValue == 0) {                     // Check if sensor is being touched
        if (!ledState) {                       // Only activate if LED is currently OFF
            ledState = true;                   // Update LED state
            digitalWrite(RED_PIN, HIGH);       // Turn on Red
            digitalWrite(GREEN_PIN, HIGH);     // Turn on Green
            digitalWrite(BLUE_PIN, HIGH);      // Turn on Blue (all ON = White)
            Serial.println("LED turned ON!");  // Debug message
        }
    } else {
        if (ledState) {                        // If touch is released and LED was ON
            ledState = false;                  // Update LED state
            digitalWrite(RED_PIN, LOW);        // Turn off Red
            digitalWrite(GREEN_PIN, LOW);      // Turn off Green
            digitalWrite(BLUE_PIN, LOW);       // Turn off Blue
            Serial.println("LED turned OFF!"); // Debug message
        }
    }

    delay(100);                                // Small pause to debounce and stabilize readings
}

The loop() function runs indefinitely. It checks the current output of the touch sensor. If the value is 0, it means the sensor is being touched. Using a control flag (ledState), the LED only turns on when transitioning from an untouched to a touched state. When the sensor value returns to 1 (no touch), the LED turns off. The delay(100) adds a 100 ms buffer to avoid noisy reads or false triggers.

🔍 Signal Processing and System Behavior

The TTP223 sensor outputs a digital signal either HIGH (1) or LOW (0) based on the presence of a human finger near its surface. When there is no touch, the output remains HIGH; when a touch is detected, it drops to LOW. The microcontroller constantly monitors this output through digitalRead(TOUCH_PIN).

The core logic of the code checks the sensor's output and, depending on the value, either turns the RGB LED ON or OFF. However, to avoid rapid toggling or flickering (which may occur due to quick or noisy signal changes), a control variable called ledState is used. This ensures that the LED changes state only when a valid transition occurs — from "not touched" to "touched" or vice versa.

📘 Step-by-Step Signal Flow Explanation

1. User touches the TTP223 sensor: The sensor detects the change in capacitance and sets its output pin to LOW (0V).
2. ESP32-S3 reads this signal: Using digitalRead(TOUCH_PIN), the microcontroller identifies that a touch occurred.
3. LED logic is triggered: If the system was OFF, the code updates ledState = true and powers all RGB channels to emit white light.
4. When touch is released: The sensor sets its output pin back to HIGH. If the LED was ON, the logic sets ledState = false and turns off the RGB channels.

🎯 Why Use a State Variable?

Without ledState, the LED would respond to every read cycle in the loop. Since the loop runs hundreds of times per second, a slight variation or noise could cause unintended flickering. The state variable ensures that the LED only toggles once per touch, making the system stable and responsive.

🧠 Educational Insight

This system is an excellent example of digital signal processing in embedded systems. Even though the sensor only provides two logic levels, the use of software logic allows us to transform a basic input into a stable and interactive output. Such approaches are common in modern human-machine interfaces, including touch lamps, interactive displays, and smart appliances.