Debugging Arduino If Statements: Hysteresis Logic for Relay Control

The Problem with Naive Arduino If Statements

The most common reason Arduino if statements fail in physical projects isn't a syntax error; it is a lack of physical-world context. When you write a simple threshold check like if (temperature > 25.0) to trigger a relay, you assume the sensor provides a perfectly stable number. In reality, a DHT22 sensor fluctuates by ±0.5°C on every read. If your room is hovering at 25.1°C, your relay will click on and off dozens of times a minute, destroying the mechanical contacts and driving you insane.

The direct answer to reliable environmental control is hysteresis (a deadband). You must use an if/else if structure with two distinct thresholds: one to turn the system on, and a lower one to turn it off. This guide walks through the exact hardware, the decision framework for choosing your logic pattern, and the complete code to implement a chatter-free relay controller.

Decision Tree: Choosing the Right Logic Pattern

Before writing code, map your physical inputs to the correct logical structure. Use this decision table to pick the exact pattern for your project.

The Verdict: For 90% of DIY environmental controllers (incubators, greenhouse fans, kegerators), the Hysteresis pattern is the mandatory choice. It terminates the decision path here: use dual thresholds.

Hardware Build: Dual-Threshold Relay Controller

This build targets the Arduino Nano V3.0 (ATmega328P). We use the Nano for its breadboard-friendly footprint and 5V logic, which natively drives standard optocoupler relay modules without level shifters.

Parts List

• Microcontroller: Arduino Nano V3.0 (ATmega328P, 16MHz) — ~$4.50 (clone) or $22 (official)
• Sensor: DHT22 / AM2302 (Do not use the DHT11; its 1°C resolution makes hysteresis tuning impossible) — ~$6.00
• Actuator: 5V 1-Channel Relay Module with Optocoupler isolation (SRD-05VDC-SL-C) — ~$2.50
• Passives: 10kΩ pull-up resistor (for DHT22 data line)
• Wiring: 22 AWG solid core jumper wires, half-size solderless breadboard

Pin Mapping Table

Complete Compilable Code with Hysteresis

This code requires the Adafruit DHT Sensor Library and the Adafruit Unified Sensor library installed via the Arduino Library Manager. It targets the Arduino Nano V3 (ATmega328P) board profile.

#include <DHT.h>

// --- PIN DEFINITIONS ---
#define DHTPIN 2          // Digital pin connected to the DHT sensor
#define DHTTYPE DHT22     // DHT 22 (AM2302)
#define RELAY_PIN 4       // Digital pin connected to Relay IN

// --- HYSTERESIS THRESHOLDS ---
#define TEMP_ON 26.0      // Turn relay ON if temp exceeds this (°C)
#define TEMP_OFF 24.0     // Turn relay OFF if temp drops below this (°C)

// --- SYSTEM STATE ---
bool relayState = false;  // Track physical state to avoid redundant writes
unsigned long lastReadTime = 0;
const unsigned long READ_INTERVAL = 2000; // Poll every 2 seconds

DHT dht(DHTPIN, DHTTYPE);

void setup() {
  Serial.begin(115200);
  pinMode(RELAY_PIN, OUTPUT);
  
  // Initialize relay to OFF state (Active LOW modules require HIGH to turn off)
  digitalWrite(RELAY_PIN, HIGH); 
  dht.begin();
  
  Serial.println("System Initialized. Hysteresis Controller Active.");
}

void loop() {
  // Non-blocking timer check
  unsigned long currentMillis = millis();
  if (currentMillis - lastReadTime >= READ_INTERVAL) {
    lastReadTime = currentMillis;
    
    float h = dht.readHumidity();
    float t = dht.readTemperature(); // Celsius by default

    // --- ERROR HANDLING ---
    if (isnan(h) || isnan(t)) {
      Serial.println("ERROR: Failed to read from DHT sensor! Check wiring.");
      // Fail-safe: Turn off relay if we lose sensor data
      if (relayState) {
        digitalWrite(RELAY_PIN, HIGH);
        relayState = false;
      }
      return; // Exit loop iteration early
    }

    // --- HYSTERESIS LOGIC ---
    if (t >= TEMP_ON && !relayState) {
      digitalWrite(RELAY_PIN, LOW); // Active LOW: LOW turns relay ON
      relayState = true;
      Serial.print("RELAY ON  | Temp: "); Serial.println(t);
    } 
    else if (t <= TEMP_OFF && relayState) {
      digitalWrite(RELAY_PIN, HIGH); // Active LOW: HIGH turns relay OFF
      relayState = false;
      Serial.print("RELAY OFF | Temp: "); Serial.println(t);
    } 
    else {
      // In the deadband zone, do nothing to the pin
      Serial.print("HOLDING   | Temp: "); Serial.println(t);
    }
  }
}

Debugging: First Three Things to Check When Logic Fails

When your relay isn't clicking or the serial monitor is throwing garbage, follow this ranked troubleshooting path.

1. Syntax Error: expected primary-expression before ')' token

The Cause: You used the assignment operator (=) instead of the equality operator (==) inside the if condition, or you forgot a parenthesis. For example, writing if (t = 25.0) assigns 25.0 to t and evaluates to true, breaking your logic and often throwing a compiler warning or error depending on the IDE version.

The Fix: Always use == for comparison, >= for thresholds. Never put a semicolon at the end of the if statement line (e.g., if (t > 25);), which terminates the block prematurely.

2. Runtime Error: Failed to read from DHT sensor!

The Cause: The isnan() check triggered. The DHT22 uses a custom single-wire protocol that is highly sensitive to timing interrupts and missing pull-up resistors.

The Fix: 1. Verify the 10kΩ pull-up resistor is physically connected between the Data pin and 5V. 2. Ensure you are not calling dht.readTemperature() faster than once every 2 seconds (the DHT22 hardware limit). 3. Check that your USB cable is data-capable and not dropping voltage below 4.8V under relay load.

3. Physical Failure: Relay Chatters Rapidly (Click-Click-Click)

The Cause: You bypassed the hysteresis logic and used a simple if (t > 25.0) { on } else { off }. The sensor noise is crossing the 25.0 threshold on alternating reads.

The Fix: Implement the dual-threshold if/else if structure provided in the code above. Ensure the gap between TEMP_ON and TEMP_OFF is at least 3x the sensor's stated accuracy (for DHT22 ±0.5°C, a 2.0°C deadband is safe).

Extending and Simplifying the Build

Once the baseline hysteresis controller is stable, you will inevitably need to scale it. Here is how to extend the logic without rewriting the core architecture.

• Add a Second Stage (Cooling + Heating): Map a second relay to D5. Create a second set of thresholds (e.g., HEAT_ON = 18.0, HEAT_OFF = 20.0). Add a secondary else if block. Ensure you add a software interlock (e.g., if (relayStateCool == false)) to prevent both relays from engaging simultaneously and fighting each other.
• Simplify with a State Machine: If you add an LCD screen, a manual override button, and WiFi, nested if statements will become unreadable. Refactor the logic into a switch(currentState) block where states are STATE_IDLE, STATE_COOLING, and STATE_ERROR. This isolates the physical pin writes from the sensor polling logic.
• Upgrade the Sensor: If you need faster polling or higher resolution, swap the DHT22 for a BME280 on the I2C bus. The I2C protocol handles timing interrupts much better than the DHT single-wire protocol, eliminating the isnan() timeout errors entirely.

By treating Arduino if statements not just as syntax, but as physical control mechanisms that require deadbands and non-blocking execution, you bridge the gap between a blinking LED tutorial and a reliable, real-world embedded system.