Boolean Logic Gates

Learning Goals 5 min

By the end of this lesson you will be able to:

1. Use Arduino's three boolean operators — && (AND), || (OR), ! (NOT) — and explain what each one returns for every combination of true/false inputs.
2. Write a truth table for any expression involving these operators, and use the table as a debugging tool when an expression behaves unexpectedly.
3. Recognise that the same three operations exist physically as logic gates inside every chip on earth — so the AND in your sketch is the conceptual same thing as the AND in the Arduino's silicon.

Warm-Up 10 min

You've already used && and || for two-button combos since L01-21. Today they get their proper name — boolean operators — and a third sibling, ! (NOT), joins the team. Together these three are the entire vocabulary of digital logic, and they show up everywhere from your code to the silicon inside the chip running it.

Quick-fire puzzle

Read these everyday sentences carefully — they hide a famous trap of how the word "and" is used in English vs in code.

1. "You can have dessert if you eat your vegetables and your fish." — When can you have dessert?
2. "This drink is suitable for vegetarians and vegans." — Who can drink it?
3. "Please bring your passport and your boarding pass." — What two items do you need?

New Concept — three operators, three tables 20 min

The big idea — boolean values are bits

A boolean value has exactly two possibilities: true or false. In Arduino code, all of the following are interchangeable ways of writing the same two values:

• true / false — the keyword forms; clearest in conditions.
• HIGH / LOW — what digitalRead returns; same numeric values.
• 1 / 0 — the raw integer; what's actually stored in memory.

The Arduino has a dedicated type for them: bool. You've been using bool-shaped values implicitly since L01-08 — every if condition is one. Today they become first-class citizens with their own operators.

Operator 1 — AND (&&)

a && b is true only when both a and b are true. Truth table:

Three falses, one true — only the bottom row qualifies. Real-world reading: "the alarm fires only if the door is open AND the system is armed."

Operator 2 — OR (||)

a || b is true when at least one of a or b is true. Truth table:

Three trues, one false — only "both false" fails. Real-world reading: "the light turns on if the motion sensor fires OR the button is pressed."

Operator 3 — NOT (!)

!a is true when a is false, and false when a is true. It flips the value. Truth table (only one input — there are only two rows):

Real-world reading: "the LED turns on when the button is NOT pressed" — useful with INPUT_PULLUP where a pressed button reads LOW.

Combining them — compound expressions

You can chain operators freely. Use parentheses to make the order explicit and the meaning unambiguous:

if (armed && (doorOpen || windowOpen)) {
  // fire alarm if armed AND (door OR window is open)
}

if (!buttonPressed) {
  // runs when button is NOT being held
}

if (a && !b) {
  // "a but not b" — fires only when a is true AND b is false
}

The trick to reading a long boolean expression is to build its truth table in your head, row by row. If the expression has three inputs (a, b, c), there are eight rows (2 × 2 × 2). Four inputs — sixteen. The number of rows doubles per input, which is exactly why too many inputs in one condition becomes unreadable.

Gates inside the chip

Every chip you've touched contains millions of physical implementations of these three operators. They're called logic gates:

• AND gate — two input wires, one output wire. Output is HIGH only when both inputs are HIGH. The && in your code, in transistors.
• OR gate — output HIGH when at least one input is HIGH. The || in your code, in transistors.
• NOT gate (also called an "inverter") — one input, one output. Output is the opposite. The ! in your code, in transistors.

Each gate is roughly four transistors (about a billionth of a square millimetre). Your Uno's chip has roughly 100,000 of them; a modern phone CPU has tens of billions. They have schematic symbols you'll see on circuit diagrams:

Short-circuit evaluation — a useful detail

When the chip evaluates a && b, it checks a first. If a is false, the whole expression is automatically false — there's no need to check b, so the chip doesn't bother. Same for a || b: if a is true, the chip skips b.

This is called short-circuit evaluation. Two reasons it matters:

• Speed — skipping unnecessary work, especially when the second operand is an expensive function call.
• Safety — you can put a guard first: if (n > 0 && arr[n - 1] == 5) safely handles n = 0 because the array access is never evaluated.

Why it matters

Every conditional you'll ever write — in Arduino, in Python, in JavaScript, in spreadsheet formulas, in database queries — is built from these three operators. Every logic chip ever fabricated implements them in silicon. The truth-table tool you learn today is the universal language for reasoning about digital logic: ten minutes of practice with truth tables saves hours of "why doesn't my condition do what I expect" debugging.

Worked Example — three LEDs, three operators 20 min

One sketch that visibly shows each operator's truth table in real time. Two buttons drive three LEDs — one per operator. Press the buttons in all four combinations; each LED's behaviour proves the operator's truth table.

The wiring

Reuse parts from earlier lessons — nothing new:

• Two buttons on D6 (A) and D7 (B) with INPUT_PULLUP (L01-21 wiring).
• Three LEDs on D9, D10, D11 with 220 Ω resistors (L01-15 wiring), sharing GND through the − rail.

The sketch

// Visual truth table — three LEDs prove three operators
const int BTN_A   = 6;
const int BTN_B   = 7;
const int LED_AND = 9;
const int LED_OR  = 10;
const int LED_NOT = 11;

void setup() {
  Serial.begin(9600);
  pinMode(BTN_A, INPUT_PULLUP);
  pinMode(BTN_B, INPUT_PULLUP);
  pinMode(LED_AND, OUTPUT);
  pinMode(LED_OR, OUTPUT);
  pinMode(LED_NOT, OUTPUT);
}

void loop() {
  // Read raw button state; LOW = pressed because of INPUT_PULLUP
  bool a = (digitalRead(BTN_A) == LOW);
  bool b = (digitalRead(BTN_B) == LOW);

  // Each LED demonstrates one operator
  digitalWrite(LED_AND, a && b);     // on only when both pressed
  digitalWrite(LED_OR,  a || b);     // on when at least one pressed
  digitalWrite(LED_NOT, !a);          // on when A is NOT pressed

  Serial.print("a="); Serial.print(a);
  Serial.print(" b="); Serial.print(b);
  Serial.print(" AND="); Serial.print(a && b);
  Serial.print(" OR=");  Serial.print(a || b);
  Serial.print(" NOT(a)="); Serial.println(!a);
  delay(100);
}

Try every row of the truth table

1. Upload at 9600 baud. Open the Monitor.
2. Press neither button. Monitor: a=0 b=0 AND=0 OR=0 NOT(a)=1. LED 9 off, LED 10 off, LED 11 on. (NOT-A is true because A isn't pressed.)
3. Press just A. a=1 b=0 AND=0 OR=1 NOT(a)=0. LED 9 off, LED 10 on, LED 11 off.
4. Press just B. a=0 b=1 AND=0 OR=1 NOT(a)=1. LED 9 off, LED 10 on, LED 11 on (A still isn't pressed).
5. Press both. a=1 b=1 AND=1 OR=1 NOT(a)=0. All three light up except NOT-A.

The Monitor's rows match the truth tables in the New Concept exactly. You've just used three buttons and three LEDs to physically demonstrate the truth tables of every logic gate in computing.

Trace a compound expression on paper

For the expression a && !b (read: "A is pressed but B is not"), fill in the truth table for all four combinations of A and B.

Adding the intermediate !b column makes the final column easy: just AND the first column with the third. This is exactly how computer scientists work through any unfamiliar boolean expression — one operator at a time, intermediate columns first.

Try It Yourself — three boolean drills 15 min

digitalWrite(LED_AND, !(a && b));      // NAND now
digitalWrite(LED_OR,  !(a || b));      // NOR now
digitalWrite(LED_NOT, !a);             // unchanged

const int ARMED      = 5;
const int DOOR       = 6;
const int WINDOW     = 7;
const int ALARM_LED  = 9;
const int BUZZER     = 8;

void setup() {
  pinMode(ARMED, INPUT_PULLUP);
  pinMode(DOOR, INPUT_PULLUP);
  pinMode(WINDOW, INPUT_PULLUP);
  pinMode(ALARM_LED, OUTPUT);
  pinMode(BUZZER, OUTPUT);
}

void loop() {
  bool armed  = (digitalRead(ARMED)  == LOW);
  bool door   = (digitalRead(DOOR)   == LOW);
  bool window = (digitalRead(WINDOW) == LOW);

  bool fire = armed && (door || window);
  digitalWrite(ALARM_LED, fire);
  if (fire) tone(BUZZER, 1000);
  else     noTone(BUZZER);
}

Mini-Challenge — build XOR from AND/OR/NOT 10 min

"Exclusive OR — on when one but not both"

XOR ("exclusive or") is a fourth gate that's not built into C++ as a boolean operator. It's true when exactly one of its two inputs is true — but not when both are. Your challenge: implement XOR using only &&, ||, and !, then wire it to a fourth LED to verify it works.

Two valid one-liner expressions both produce XOR (there are others):

• Form 1: (a || b) && !(a && b) — "at least one AND not both"
• Form 2: (a && !b) || (!a && b) — "A and not B, or not A and B"

Your task:

1. Pick one of the two forms. Don't peek at the other yet.
2. Write a sketch that reuses the worked example's wiring (two buttons on D6/D7, three LEDs you can repurpose). Drive any one of the LEDs with your XOR expression.
3. Test all four button combinations and confirm: LED is on for "just A" and "just B", off for "neither" and "both".
4. On paper, build the truth table for your chosen form and confirm it matches XOR.
5. Now look at the other form. Build its truth table. Same output for every row? (It should be — both forms compute XOR.)

It works if:

• Your XOR LED is on for exactly two of the four button combinations.
• The two on-rows are "A only" and "B only" — not "neither" and not "both".
• Your paper truth table matches the LED's behaviour exactly.

// XOR using AND / OR / NOT — built from L01-42's primitives
const int BTN_A   = 6;
const int BTN_B   = 7;
const int LED_XOR = 9;

void setup() {
  pinMode(BTN_A, INPUT_PULLUP);
  pinMode(BTN_B, INPUT_PULLUP);
  pinMode(LED_XOR, OUTPUT);
}

void loop() {
  bool a = (digitalRead(BTN_A) == LOW);
  bool b = (digitalRead(BTN_B) == LOW);
  bool xor_result = (a || b) && !(a && b);
  digitalWrite(LED_XOR, xor_result);
}

Recap 5 min

Three operators, three truth tables, three physical gates: && (AND, both true), || (OR, at least one true), ! (NOT, flip). They live in your code as conditionals and in the chip as billions of tiny transistor circuits. Combine them with parentheses and build any logic you need — and when an expression confuses you, write its truth table. NAND, NOR and XOR are useful derived gates built from the three primitives. Short-circuit evaluation makes && and || safe to use as guard clauses. From here on, every boolean expression you write is a tiny computer-science exercise — and you have the tools to read any of them.

Boolean

A value that is either true or false — equivalently HIGH/LOW or 1/0. Named after George Boole, the 19th-century mathematician who invented this algebra. Arduino's type is bool.

AND (&&)

Boolean operator that returns true only when both operands are true. The strict English-style "and".

OR (||)

Boolean operator that returns true when at least one operand is true. Inclusive — also true when both are true.

NOT (!)

Boolean operator that takes one operand and returns the opposite. Applies only to the immediately following value or parenthesised group.

Truth table

A small table listing every combination of input values and the resulting output of a boolean expression. The standard tool for reasoning about and debugging logic — exhaustive, never ambiguous.

Logic gate

A physical circuit (typically four transistors) inside a chip that implements one of the boolean operators. Every microprocessor is built from billions of them wired together.

NAND / NOR / XOR

Derived gates: NAND = NOT(AND), NOR = NOT(OR), XOR = "exactly one". All three can be built from the basic AND / OR / NOT primitives. NAND is so universal that entire chips are built from NAND alone.

Short-circuit evaluation

The behaviour that && stops at the first false operand and || stops at the first true one. Useful for speed and for "guard then access" patterns like if (n > 0 && arr[n - 1] == 5).

De Morgan's Law

The identity !(a && b) == (!a || !b) and its dual !(a || b) == (!a && !b). Lets you push NOT inside a parenthesised group by flipping the operator. Useful when you're trying to simplify or reverse a condition.

Bitwise (&, |) vs boolean (&&, ||)

The single-character versions operate on every bit of a number independently (Level 2 topic). The doubled versions operate on whole true/false values. Use the doubled forms in if conditions.

Homework 5 min

The three-input puzzle. No Arduino needed for the maths part. On paper, build the eight-row truth table (three inputs A, B, C = 2³ = 8 rows) for each expression below:

1. a && b && c
2. a || b || c
3. a && (b || c)
4. (a && b) || (b && c) || (a && c)   (this is "majority vote" — true when at least two of three are true)

Then build it as a sketch. Wire three buttons on D5, D6, D7 with INPUT_PULLUP and one LED on D9. The LED should light up only when the majority vote expression is true — at least two of three buttons pressed.

Also: a design reflection on paper.

• The "majority vote" pattern is used in real systems for fault tolerance — three redundant sensors voting on a reading. Why might that be safer than just one sensor? ____
• How many rows are in the truth table for an expression with five boolean inputs? Six? Ten? Why does this make "really long conditions" hard to reason about? ____
• Of the three primitive gates (AND, OR, NOT), which one do you think is used most often in everyday code? Which gets used least? Justify briefly. ____
• The early electronic computer ENIAC (1945) had 17,468 vacuum-tube gates. A modern phone has about 50 billion. Roughly how many times more? ____ (Hint: a calculator is fine.)

Bring back next class:

• The saved .ino file (call it majority-vote).
• A photo of your four hand-drawn truth tables in your notebook.
• Your four written reflection answers, in your notebook.

Heads up for next class: L01-43 "Auto Night Light" is the Cluster F project. It combines the LDR (L01-36) with a threshold decision (boolean logic from today) to build your first real sensor product — a light that knows when to turn itself on. After three lessons of building blocks, you finally combine them.