Evaluating an Expression: Boolean Logic in Circuits and Code

A Boolean expression is a logical combination of variables and operators that evaluates strictly to a binary state of true (1) or false (0). Unlike algebraic equations that yield a continuous spectrum of numbers, this logical construct forces a definitive yes-or-no outcome, serving as the absolute bedrock for everything from physical 7400-series logic gates to the if() statements routing current in your ESP32 firmware. When you are evaluating an expression, boolean rules dictate that no matter how complex the chain of logic gets, the final output must collapse into a single HIGH or LOW signal.

The Core Operators and Hardware Thresholds

Before wiring up discrete logic ICs or writing microcontroller firmware, you need to understand how abstract logic maps to physical voltage. A common mistake on the bench is assuming a logical '1' is always exactly 5V or 3.3V. In reality, hardware evaluates an expression based on specific voltage thresholds (V_IH for HIGH, V_IL for LOW).

Source: Texas Instruments SN74HC08 Datasheet

Worked Numeric Example: Industrial Safety Interlock

Let’s move from abstract theory to a real-world circuit. Suppose you are wiring a 24V DC motor contactor for a workshop lathe. The motor should only run if the Start button is pressed, the Emergency Stop is NOT pressed, and the Thermal Overload relay has NOT tripped.

We define our variables based on physical switch states:

• S = Start Button (1 = Pressed, 0 = Released)
• E = E-Stop Button (1 = Pressed/Engaged, 0 = Released)
• T = Thermal Overload (1 = Tripped, 0 = Clear)
• M = Motor Contactor Coil (1 = Energized, 0 = De-energized)

The boolean expression for this safety interlock is:

M = S · E' · T'

The Scenario: The operator presses the Start button (S=1). The E-Stop is released (E=0). However, the motor previously overheated, and the thermal relay is still tripped (T=1).

Evaluating the Expression Step-by-Step:

1. Substitute the real values: M = 1 · (NOT 0) · (NOT 1)
2. Apply the NOT operators first: NOT 0 = 1, and NOT 1 = 0.
3. The expression simplifies to: M = 1 · 1 · 0
4. Apply the AND operator: 1 AND 1 = 1. Then 1 AND 0 = 0.
5. Final Result: M = 0.

Where You Meet This in Practice

Understanding how to parse and evaluate an expression is critical across three distinct domains in electrical and electronics work:

1. Discrete Hardware Logic (7400 / 4000 Series)

When building a custom PCB or wiring a breadboard prototype, you physically manifest these expressions using ICs. An expression like X = (A + B) · C requires a physical OR gate (like the 74HC32) feeding into an AND gate (74HC08). The evaluation happens at the speed of electron propagation through the silicon gates (typically a few nanoseconds of propagation delay).

2. Microcontroller Firmware (Arduino / ESP32)

In C/C++ firmware, boolean expressions act as the gatekeepers for your if(), while(), and for() loops. If you are reading a BME280 sensor on an ESP32, your expression might look like if (temp > 50.0 && humidity < 80.0). The compiler evaluates the left side first; if temp > 50.0 is false, it uses "short-circuit evaluation" and ignores the humidity check entirely to save clock cycles.

3. PLC Ladder Logic (Industrial Automation)

In programmable logic controllers, boolean expressions are drawn as horizontal rungs. An AND operation is represented by instructions in series (e.g., Allen-Bradley's XIC - Examine If Closed), while an OR operation is represented by parallel branches. The PLC scan cycle evaluates the expression from left to right, top to bottom, updating the physical output modules only when the entire rung evaluates to true.

The Most Common Confusion: Bitwise vs. Logical Operators

The single most frequent bug encountered by hobbyists and junior engineers when writing C++ for microcontrollers is confusing bitwise operators with logical operators. This happens when evaluating an expression where boolean logic is expected, but binary math is performed instead.

The Fatal Arduino Mistake:
Imagine you want to check if both GPIO pin 2 and GPIO pin 3 are reading HIGH. A beginner might write:

// WRONG: Bitwise AND on the pin NUMBERS, not the pin STATES
if (2 & 3) { 
  digitalWrite(LED_BUILTIN, HIGH); 
}

Because 2 in binary is 0010 and 3 is 0011, a bitwise AND (0010 & 0011) results in 0010 (which is decimal 2). In C++, any non-zero integer evaluates to true. Therefore, this if statement will always trigger, completely ignoring the actual physical voltage on the pins!

The Correct Boolean Expression:

// CORRECT: Logical AND on the evaluated STATES
int stateA = digitalRead(2);
int stateB = digitalRead(3);
if (stateA == HIGH && stateB == HIGH) { 
  digitalWrite(LED_BUILTIN, HIGH); 
}

Frequently Asked Questions