Compound Boolean Expression Guide: Debugging Logic Precedence in PLC and ESP32 Circuits

A compound boolean expression is a logical statement that combines two or more individual true/false conditions using operators like AND, OR, and NOT to yield a single final true or false outcome. In electrical and electronic systems, this single binary outcome is the exact threshold that dictates whether a physical output—like a motor starter coil, a solid-state relay, or a microcontroller GPIO pin—energizes or stays dead. When you write a line of code or wire a ladder logic rung, you are building a bridge between abstract mathematics and physical electrons. If the logic is flawed, the hardware behaves unpredictably, often with expensive or dangerous consequences.

What a compound boolean expression changes in a real installation is the permissive interlock of the machinery. It ensures that a high-voltage contactor only pulls in when multiple independent safety and operational states align. However, the most common point of failure isn't a misunderstanding of what AND or OR means; it is a fundamental confusion regarding operator precedence and the assumption that logic evaluates strictly from left to right.

The Silent Machine Killer: Operator Precedence

In both C++ (used for Arduino/ESP32) and IEC 61131-3 (the international standard for PLC programming), logical operators do not carry equal weight. The NOT operator evaluates first, followed by AND, and finally OR. This hierarchy is where builders get burned.

To visualize this, use the only analogy you will ever need for boolean logic: physical switches. Think of an AND operator as switches wired in series; current only flows if both are closed. Think of an OR operator as switches wired in parallel; current flows if either path is closed. If you write the expression A AND B OR C, the system builds a circuit where A and B are in series with each other, and that entire series branch is wired in parallel with C. If C closes, current flows, completely bypassing the A and B requirement.

According to the foundational principles outlined by All About Circuits, Boolean algebra dictates that multiplication (AND) takes precedence over addition (OR). Forgetting to wrap your OR conditions in parentheses is the equivalent of wiring a safety interlock in parallel with a manual override, defeating the safety interlock entirely.

Where You Meet This In Practice

You will encounter compound boolean expressions across three primary domains in modern electrical work:

• Microcontroller Firmware (ESP32/Arduino): Written in C/C++ inside if() statements or while() loops. Here, you use && for AND, || for OR, and ! for NOT. The Espressif ESP-IDF GPIO documentation relies heavily on these expressions to manage pin state interrupts and peripheral enables.
• PLC Ladder Logic: Represented visually as horizontal rungs. Normally Open (NO) contacts in series represent AND; NO contacts in parallel branches represent OR. The compound expression is evaluated during the PLC's scan cycle from left to right, but parallel branches resolve as logical ORs.
• Hardwired Relay Logic & 7400-Series ICs: Before microcontrollers, compound expressions were physically wired using relay contacts or TTL logic gates (like the 7408 AND gate and 7432 OR gate). The expression was hardcoded into the copper traces and wire jumpers.

Real-World Scenario Walkthrough: The Flooded CNC Bed

To understand how a missing parenthesis destroys hardware, let's look at a real bench scenario involving a retrofit CNC machine coolant system.

The Setup

We are controlling a 120V AC coolant pump using an ESP32-WROOM-32. The pump should only run if the spindle is spinning AND the coolant reservoir is full, OR if the operator presses a manual flush override button.

• Input A (Spindle ON): 24V proximity sensor stepped down via a PC817 optocoupler to 3.3V on GPIO 4.
• Input B (Coolant Level OK): 24V float switch stepped down via optocoupler to 3.3V on GPIO 5.
• Input C (Manual Override): Momentary pushbutton pulling 3.3V on GPIO 18.
• Output (Pump Relay): GPIO 19 driving an Omron G3MB-202P solid-state relay.

The Numbers and The Mistake

The intended logic is: Spindle AND (Coolant OR Override).
The programmer, rushing to finish the firmware, wrote the C++ expression without parentheses:

if (digitalRead(spindle) && digitalRead(coolant) || digitalRead(override)) {
  digitalWrite(pump_relay, HIGH);
}

The Outcome: What Went Wrong

Because && binds tighter than ||, the ESP32 evaluated the expression as: (Spindle AND Coolant) OR Override. During testing, the operator pressed the Manual Override button to flush the lines while the spindle was OFF. The override pin (GPIO 18) went HIGH (3.3V). The OR condition was satisfied. The ESP32 drove GPIO 19 HIGH, energizing the Omron SSR, and the coolant pump turned on. Because the spindle wasn't spinning to distribute the fluid, the coolant pooled in the machine bed, overflowing the chip tray and flooding the shop floor.

The fix took two keystrokes: adding ( and ) around the OR condition. The physical hardware was fine; the compound boolean expression was fatally flawed.

Bench Debugging: Tracing Logic States with a Multimeter

When a compound expression misbehaves, do not immediately rewrite the code or rewire the PLC. Prove the physical states first using a digital multimeter (DMM). Follow these numbered steps to isolate the failure:

1. Verify Input Thresholds: Set your DMM to DC Volts. Probe the input side of your optocouplers or PLC input terminals. A 24V industrial sensor must read >20V to reliably trigger a logic HIGH. If it reads 14V, you have a voltage drop issue in the field wiring, not a logic error.
2. Verify Microcontroller Pin Voltages: Probe the actual GPIO pins on the ESP32 or Arduino. An ESP32 logic HIGH must be between 2.8V and 3.3V. If you are reading 1.1V, your pin might be configured as an analog input, or you have a floating ground on your sensor.
3. Force the Truth Table: Manually trigger each sensor one by one. Use the serial monitor or PLC watch window to observe the raw boolean variables. Compare the live output against your intended truth table.
4. Measure the Output Drive: Probe the output pin driving the relay. If the logic evaluates to TRUE but the pin reads 0V, you may have exceeded the GPIO current limit (e.g., trying to pull 30mA from an ESP32 pin rated for 12mA), causing the internal silicon to brownout or latch low.

FAQ: Debugging Compound Logic on the Bench