Logical AND in Arduino: && vs & Operators and Common Errors

The logical AND in Arduino C++ is written as &&. It evaluates to true (1) only if both the left and right operands are true. However, a massive source of bench-time bugs comes from confusing the logical AND (&&) with the bitwise AND (&). While && evaluates the truthiness of entire variables and supports short-circuit evaluation, & performs a bit-by-bit mathematical operation on the binary representation of the numbers. Using the wrong one will either silently corrupt your logic or trigger a compiler fault.

This guide breaks down the exact differences, provides a complete dual-sensor safety interlock build using the modern Arduino Uno R4 Minima, and details how to debug the most common compiler errors associated with AND operators.

The Operator Matrix: Logical vs. Bitwise AND

Before wiring up sensors, you need to know exactly which operator to type. Here is the definitive matrix for AND operations in the Arduino GCC/AVR-ARM toolchain.

Project Build: Dual-Sensor Safety Interlock

To demonstrate the logical AND in a real-world scenario, we are building a safety interlock. A 5V relay will only engage if a physical guard door is closed (limit switch) AND the internal chamber temperature is below a safe threshold. This prevents a heater from turning on if the door is open or if the chamber is already overheating.

Parts List

• Microcontroller: Arduino Uno R4 Minima (RA4M1 ARM Cortex-M4, 48MHz, native 5V logic)
• Switch: Omron D2F-01 Limit Switch (Snap-action, SPDT)
• Temperature Sensor: DS18B20 Digital Sensor (TO-92 package, external power mode)
• Resistor: 4.7kΩ 1/4W (Pull-up for OneWire data line)
• Actuator: 5V Relay Module with Optocoupler Isolation (Active LOW trigger)
• Wiring: 22 AWG solid core hook-up wire

Pin Mapping Table

Complete Code with Error Handling

This code targets the Arduino Uno R4 Minima. It requires the OneWire and DallasTemperature libraries, which you can install via the Arduino Library Manager. The code includes explicit error handling for the DS18B20, which returns -127.0°C when disconnected or missing its pull-up resistor.

#include <OneWire.h>
#include <DallasTemperature.h>

// --- PIN DEFINITIONS ---
const uint8_t PIN_LIMIT_SWITCH = 2; // Digital pin 2 (Internal pull-up enabled)
const uint8_t PIN_TEMP_SENSOR  = 3; // Digital pin 3 (OneWire data)
const uint8_t PIN_RELAY        = 8; // Digital pin 8 (Relay IN, Active LOW)

// --- THRESHOLDS & CONSTANTS ---
const float MAX_SAFE_TEMP    = 50.0;  // Celsius
const float SENSOR_ERROR_TEMP = -127.0; // DS18B20 disconnected error code
const unsigned long POLL_INTERVAL = 500; // milliseconds

// --- OBJECTS ---
OneWire oneWire(PIN_TEMP_SENSOR);
DallasTemperature sensors(&oneWire);

unsigned long lastPollTime = 0;

void setup() {
  Serial.begin(115200);
  
  // Configure Pins
  pinMode(PIN_LIMIT_SWITCH, INPUT_PULLUP); // Switch pulls to GND when closed
  pinMode(PIN_RELAY, OUTPUT);
  
  // Default to SAFE state (Relay OFF)
  digitalWrite(PIN_RELAY, HIGH); // Active LOW relay: HIGH = OFF
  
  sensors.begin();
  Serial.println("Safety Interlock Initialized.");
}

void loop() {
  // Non-blocking delay for sensor polling
  if (millis() - lastPollTime >= POLL_INTERVAL) {
    lastPollTime = millis();
    evaluateSafetyInterlock();
  }
}

void evaluateSafetyInterlock() {
  // 1. Read fast digital sensor first (Short-circuit evaluation benefit)
  bool doorIsClosed = (digitalRead(PIN_LIMIT_SWITCH) == LOW);
  
  // 2. Read slow digital sensor
  sensors.requestTemperatures();
  float currentTemp = sensors.getTempCByIndex(0);
  
  // 3. Error Handling: Check for disconnected sensor
  bool tempIsSafe = false;
  bool sensorFault = false;
  
  if (currentTemp <= SENSOR_ERROR_TEMP + 1.0) { // Allow slight float margin
    sensorFault = true;
    Serial.println("ERROR: DS18B20 Disconnected or missing pull-up!");
  } else {
    tempIsSafe = (currentTemp < MAX_SAFE_TEMP);
  }
  
  // 4. THE LOGICAL AND EVALUATION
  // Relay engages ONLY if door is closed AND temp is safe AND no sensor fault
  if (doorIsClosed && tempIsSafe && !sensorFault) {
    digitalWrite(PIN_RELAY, LOW); // Turn Relay ON
    Serial.print("SAFE: Relay ENGAGED. Temp: ");
    Serial.println(currentTemp);
  } else {
    digitalWrite(PIN_RELAY, HIGH); // Turn Relay OFF
    Serial.print("INTERLOCK: Relay OFF. Door: ");
    Serial.print(doorIsClosed ? "Closed" : "OPEN");
    Serial.print(" | Temp: ");
    Serial.println(currentTemp);
  }
}

Debugging: "expected primary-expression before '&&' token"

When working with the logical AND in Arduino, syntax errors are common, especially when chaining multiple conditions. The most frequent compiler error you will encounter is:

error: expected primary-expression before '&&' token

This error means the compiler found the && operator but did not find a valid variable, function, or literal value immediately preceding it. Here are the ranked causes and how to fix them.

Ranked Causes

1. Stray or Double Operators: You accidentally typed && && or & &&. The compiler reads the first operator, expects a value, and hits the second operator instead.
   Fix: Delete the duplicate operator.
2. Missing Left Operand: You wrote something like if (&& doorIsClosed) or left a variable name out after a refactoring.
   Fix: Ensure every && has a valid boolean expression on both its left and right sides.
3. Trailing Operator at Line End: You broke a long if statement across multiple lines and left an && dangling at the end of a commented-out line, or placed it right before a closing parenthesis.
   Fix: Check your line breaks and parentheses matching.

The First Three Things to Check When It Fails

If your logical AND statement is throwing compiler errors or failing silently at runtime, run this 3-step checklist:

1. Check Parentheses Matching: Every opening ( must have a closing ). A missing parenthesis before the && will shift the compiler's parsing context and trigger the primary-expression error.
2. Verify Function Call Syntax: If your operand is a function, ensure you included the parentheses. Writing if (digitalRead && sensor2) instead of if (digitalRead(PIN) == HIGH && sensor2) passes a function pointer instead of a boolean, causing type mismatch errors.
3. Confirm Variable Types: Ensure the variables on both sides of the && actually resolve to a boolean or integer. If you are comparing strings, remember that == works for String objects, but you must use strcmp() for C-style char arrays before applying the logical AND.

Extending and Simplifying the Build

Once the base interlock is running on your Uno R4 Minima, you will likely need to adapt it for different bench or jobsite requirements.

How to Extend (Scaling Up)

If you need to add a third safety condition (e.g., an emergency stop button or a pressure transducer), you can chain additional && operators. However, chaining more than three conditions in a single if statement becomes difficult to debug. Instead, use boolean flags:

bool isSafe = doorIsClosed;
isSafe = isSafe && tempIsSafe;
isSafe = isSafe && pressureIsNominal;
isSafe = isSafe && !eStopTriggered;

if (isSafe) { /* engage */ }

This approach allows you to print the exact state of isSafe after every single check via Serial, making runtime debugging trivial.

How to Simplify (Stripping it Down)

If you do not need the precision of a digital temperature sensor and just want a basic over-temp cutoff, replace the DS18B20 with an analog LM35 or a simple NTC thermistor voltage divider. This eliminates the need for the OneWire library, frees up digital pins, and reduces the code footprint by roughly 4KB of flash memory. Simply read the analog pin, map the voltage to temperature, and feed that boolean result into your logical AND statement.

For authoritative syntax references, always consult the Arduino Language Reference for Logical AND and the C++ Standard Operator Documentation to understand how short-circuiting behaves at the compiler level.