How to Evaluate a Boolean Expression in ESP32 and Hardware Logic

A boolean expression is a logical statement combining variables and operators that strictly evaluates to either a true (1/HIGH) or false (0/LOW) state. In a physical circuit or installation, the evaluated result of this expression directly changes the physical state of an output: it drives a microcontroller GPIO pin HIGH or LOW, energizes a 24V DC relay coil, or dictates whether a software interrupt service routine (ISR) executes. Whether you are wiring a hardwired safety interlock on a motor starter or writing C++ firmware for an ESP32-S3, mastering these expressions is the bridge between abstract logic and physical electrical work.

The Core Mechanics and Operator Reference

At the bench, you implement boolean logic in two distinct ways: physically using silicon logic gates (like the 74HC series) or programmatically using logical operators in C/C++ firmware. While the mathematical theory is identical, the physical execution differs. Hardware gates evaluate all inputs simultaneously with a propagation delay measured in nanoseconds. Software logical operators, however, often use 'short-circuit evaluation'—meaning the microcontroller stops evaluating the expression the moment the final outcome is guaranteed, saving clock cycles but potentially skipping a hardware read if you aren't careful.

Think of an AND gate like two switches in series on a 120V branch circuit: current only reaches the load if both switches are closed. If the first switch is open, it doesn't matter what state the second switch is in—the circuit is dead. This is the physical equivalent of software short-circuit evaluation.

Worked Numeric Example: Sensor Interlock Logic

Let's look at a real-world scenario where a boolean expression controls a physical load. We are building a coolant pump controller using an ESP32-WROOM-32E. The pump must only run if the motor temperature is below a safe threshold AND the coolant reservoir is not empty.

• Input A (Temperature): A 4-20mA temperature transmitter mapped to 0-100°C, read via a 100Ω shunt resistor on GPIO 32 (ADC1_CH4). 20mA = 2.0V = 100°C.
• Input B (Level Switch): A float switch on GPIO 33, configured with an internal pull-up. The switch pulls the pin to GND (LOW) when the tank is full, and floats HIGH when empty.
• Output: GPIO 25 driving an opto-isolated relay module.

The target threshold is 65°C. At 65°C, the transmitter outputs 13mA. Across the 100Ω shunt, this yields 1.3V. On the ESP32's 12-bit ADC (0-4095), assuming a practical full-scale saturation of 3.1V due to internal ADC non-linearity, 1.3V translates to an raw ADC reading of roughly 1714.

Here is the C++ boolean expression evaluated in the main loop:

// Read sensors
int temp_raw = analogRead(32);
int level_state = digitalRead(33);

// The Boolean Expression
bool pump_run = (temp_raw < 1714) && (level_state == LOW);

if (pump_run) {
    digitalWrite(25, HIGH); // Energize relay
} else {
    digitalWrite(25, LOW);  // De-energize relay
}

Evaluating the Expression:
Suppose the motor heats up to 75°C. The transmitter outputs 15mA, creating 1.5V across the shunt. The ADC reads approximately 1978. The tank is full, so the float switch grounds GPIO 33, making level_state equal to 0 (LOW).

The expression evaluates as:
(1978 < 1714) && (0 == 0)
(FALSE) && (TRUE)
FALSE

Because the first operand is FALSE, the ESP32's C++ compiler short-circuits the evaluation. It doesn't even need to check the second operand to know the final result is FALSE. GPIO 25 remains LOW, the relay stays de-energized, and the pump remains off, protecting the motor from thermal damage.

Where You Meet This in Practice

You will encounter boolean expressions across three primary domains in electrical and electronics work:

1. Hardwired Relay and Contactor Logic

Before PLCs existed, industrial control panels used hardwired boolean logic. A motor starter circuit with a start button (NO), a stop button (NC), and a thermal overload (NC) is a physical boolean expression. The contactor coil energizes only when the logical AND condition of the control circuit is met. If the thermal overload trips (breaking the circuit), the expression evaluates to FALSE, dropping the contactor.

2. Microcontroller Firmware and State Machines

In embedded systems like Arduino or ESP32 projects, boolean expressions govern state machines. They determine when to transition a system from 'Idle' to 'Active', when to trigger a watchdog timer reset, or when to publish an MQTT payload. According to the Espressif GPIO documentation, properly evaluating pin states via logical expressions is critical for configuring interrupt triggers (e.g., GPIO_INTR_NEGEDGE).

3. Programmable Logic Controllers (PLCs)

In ladder logic, boolean expressions are visualized as rungs. Normally Open (NO) contacts represent standard variables, Normally Closed (NC) contacts represent NOT variables, and series/parallel branches represent AND/OR operations. The PLC scan cycle evaluates these expressions from left to right, top to bottom, updating the physical output modules at the end of the scan.

Common Confusions and Fatal Mistakes

When transitioning between hardware wiring and software coding, makers frequently make two critical errors regarding boolean logic.

Bitwise vs. Logical Operators

This is the most common embedded C bug. A logical AND (&&) evaluates the 'truthiness' of two entire conditions (any non-zero value is TRUE). A bitwise AND (&) compares the individual binary bits of two numbers.
If you write if (sensor_val & 0x0F == 5) instead of using logical operators for conditions, you are performing binary math, not logical evaluation. As noted in the Arduino Reference for Logical Operators, mixing these up will result in conditions that silently fail or trigger unpredictably, often leading to runaway hardware.

Active-Low Logic Inversion

In hardware, many safety switches and interrupts are wired 'Active-Low' using pull-up resistors. This means the physical 'triggered' state reads as a logical 0 (LOW). Makers often write if (limit_switch == HIGH), assuming HIGH means 'active'. If the switch is active-low, the boolean expression is inverted. You must write if (limit_switch == LOW) or use the NOT operator: if (!limit_switch). Forgetting this inversion is the leading cause of machinery failing to stop when a safety limit is reached.

Hardware Bounce in Logical Evaluation

A mechanical switch doesn't transition cleanly from 0 to 1. It bounces, creating rapid micro-second pulses. If your boolean expression is evaluated inside a high-speed loop without debouncing, a single button press might evaluate to TRUE, then FALSE, then TRUE again, triggering multiple relay actuations. Always debounce mechanical inputs in software or use a hardware RC filter (e.g., 10kΩ resistor and 100nF capacitor) before the signal reaches your logic gate or GPIO pin.