Interfacing a Sensor Optocoupler to ESP32: Isolated State Detection & Math

The Sensing Principle: Isolated Digital State Detection

In embedded systems, a sensor optocoupler functions as an isolated digital state sensor. Rather than measuring a proportional analog physical quantity like temperature, it detects the binary presence or absence of a target voltage—ranging from 5V logic levels up to 120VAC mains—without sharing a ground reference with your microcontroller. The input side contains an infrared LED; when the target voltage is present, current flows and the LED emits light. The output side houses a phototransistor that conducts when illuminated, effectively acting as a closed switch that pulls your microcontroller GPIO to ground.

This optical gap provides galvanic isolation, typically rated between 2,500V and 5,000V RMS. By breaking the electrical connection, the optocoupler prevents destructive ground loops, blocks high-voltage transients from frying your 3.3V ESP32, and allows you to safely sense industrial 24VDC PLC signals or AC zero-crossings for phase-controlled dimming. The output is strictly an open-collector digital signal; it does not output a variable voltage, meaning your microcontroller reads a definitive HIGH or LOW based on the phototransistor's saturation state.

Optocoupler Selection & Specifications

Not all optocouplers are built for the same sensing tasks. Using a standard DC optocoupler on an AC line will result in 60Hz flickering and eventual LED degradation, while using an AC-specific part for high-speed digital data will result in missed pulses due to slow rise/fall times. Below is a data-dense comparison of the most common sensor optocouplers used in maker and industrial prototyping as of 2026.

Wiring, Pinout, and Current-Limiting Math

The most common mistake when wiring a sensor optocoupler is treating the output like a voltage source. The phototransistor output is an open-collector switch. It can only sink current to ground; it cannot source current to VCC. Therefore, you must use a pull-up resistor on the ESP32 side to define the HIGH state when the LED is off.

PC817 Pinout and Supply Range

The Raw-to-Unit Math: Sizing the Resistors

Because the output is a digital boolean state (0V or 3.3V), the "raw-to-unit" scaling math involves calculating the exact resistor values required to force the phototransistor into saturation. If the transistor isn't fully saturated, the ESP32 GPIO will read a floating voltage (e.g., 1.8V), which sits in the undefined logic region and causes erratic behavior.

Step 1: Calculate the Input Current-Limiting Resistor ($R_{in}$)
Let's assume we are sensing a 24VDC industrial limit switch. We want a forward current ($I_f$) of 5mA to ensure good LED life while triggering the sensor.
Formula: $R_{in} = (V_{supply} - V_f) / I_f$
$R_{in} = (24V - 1.2V) / 0.005A = 4,560 \Omega$
Action: Use a standard 4.7kΩ resistor. Power dissipation is $I^2R = (0.005)^2 \times 4700 = 0.11W$, so a standard 1/4W (0.25W) resistor is perfectly safe.

Step 2: Calculate the Pull-Up Resistor ($R_{pullup}$) using CTR
The Current Transfer Ratio (CTR) dictates how much collector current ($I_c$) you get for a given LED current ($I_f$). The PC817 has a typical CTR of 50% at 5mA.
Max Collector Current: $I_c = I_f \times CTR = 5mA \times 0.50 = 2.5mA$.
To pull the ESP32 3.3V line down to a solid 0V (LOW), the optocoupler must be able to sink all the current flowing through the pull-up resistor.
Minimum Pull-Up Resistance: $R_{pullup} = V_{CC} / I_c = 3.3V / 0.0025A = 1,320 \Omega$.
Action: Use a 2.2kΩ or 4.7kΩ pull-up resistor. This limits the sink current requirement to ~1.5mA or ~0.7mA respectively, well within the 2.5mA saturation capability of the phototransistor, guaranteeing a clean 0V logic LOW.

Interference, Debounce, and ESP32 Implementation

While optocouplers eliminate galvanic ground loops, they are not immune to all interference. The primary enemy is parasitic capacitance ($C_{io}$) between the input LED and the output phototransistor. In a standard PC817, this is roughly 1pF to 2pF. If your input side switches a highly inductive load (like a 24V relay coil) without a flyback diode, the resulting massive $dV/dt$ voltage spike will couple through that 1pF capacitance and induce a transient current glitch on the output side, causing the ESP32 to register a false trigger.

Furthermore, if you are using the optocoupler to sense a mechanical switch or a bouncing relay contact, the physical bounce will be faithfully transmitted across the optical gap. You must implement software debouncing. According to the Espressif ESP-IDF GPIO documentation, handling fast state changes requires interrupt service routines (ISRs) placed in IRAM to prevent cache-miss latency.

Complete ESP32 Interrupt & Debounce Code

The following code uses a hardware interrupt to catch the exact microsecond the optocoupler pulls the pin LOW, followed by a software timer to ignore mechanical bounce. This is the robust, production-ready way to read an isolated sensor.

#include 

// Pin Definitions
const int OPTO_SENSOR_PIN = 14; // GPIO 14 supports interrupts
const int LED_STATUS_PIN = 2;   // Onboard LED

// Debounce variables
volatile unsigned long last_trigger_time = 0;
const unsigned long DEBOUNCE_DELAY_US = 5000; // 5ms debounce in microseconds
volatile bool sensor_triggered = false;

// IRAM_ATTR ensures the ISR runs from RAM, avoiding flash cache delays
void IRAM_ATTR opto_isr() {
  unsigned long current_time = micros();
  // Check if enough time has passed since the last valid trigger
  if (current_time - last_trigger_time > DEBOUNCE_DELAY_US) {
    last_trigger_time = current_time;
    sensor_triggered = true;
  }
}

void setup() {
  Serial.begin(115200);
  pinMode(LED_STATUS_PIN, OUTPUT);
  
  // Configure GPIO: INPUT mode, disable internal pull-up, use external 4.7k
  // Trigger interrupt on FALLING edge (when optocoupler pulls to GND)
  pinMode(OPTO_SENSOR_PIN, INPUT);
  attachInterrupt(digitalPinToInterrupt(OPTO_SENSOR_PIN), opto_isr, FALLING);
  
  Serial.println("Sensor Optocoupler ISR Initialized.");
}

void loop() {
  if (sensor_triggered) {
    sensor_triggered = false; // Reset flag immediately
    
    // Execute your state-change logic here
    Serial.printf("Isolated State Change Detected at %lu us\n", last_trigger_time);
    digitalWrite(LED_STATUS_PIN, !digitalRead(LED_STATUS_PIN));
  }
  
  // Main loop can handle WiFi/MQTT tasks without missing the sensor edge
  delay(10); 
}

By combining the correct current-limiting math, an external pull-up resistor, and an IRAM-allocated interrupt service routine, your sensor optocoupler circuit will reliably translate hazardous or noisy external voltages into clean, bounce-free 3.3V logic for your microcontroller. For deeper theoretical background on isolation barriers and CMTI (Common-Mode Transient Immunity), refer to the Analog Devices guide on optical isolation.