Arduino and Home Automation: Building an MQTT Relay Hub with the Uno R4 WiFi

When bridging the gap between Arduino and home automation, the biggest point of failure is rarely the code—it is the hardware architecture. Taping an ESP8266 to a 5V relay module and calling it a day usually results in brownouts, WiFi dropouts, and fried GPIO pins. If you want a rock-solid, locally-hosted smart home node that integrates seamlessly with Home Assistant or Node-RED via MQTT, you need a board with native 5V logic, robust power regulation, and a dedicated WiFi co-processor.

The Decision Matrix: Choosing Your Board for Home Automation

Before cutting wires, you must select the right microcontroller for an MQTT-based relay hub. Here is the decision path to determine which board fits your specific home automation constraints, terminating in our default recommendation for this build.

The Verdict: For a hardwired 4-channel relay hub controlling mains lighting or HVAC dampers, we are using the Arduino Uno R4 WiFi (ABX00087). It features a Renesas RA4M1 (Arm Cortex-M4) for 5V logic and timing, paired with an ESP32-S3 acting purely as a WiFi/Bluetooth modem. This separation prevents the WiFi stack from interrupting your relay-switching interrupts, a common plague in standard ESP32 home automation builds.

Parts List & Hardware Specifications

Sourcing the exact variants below prevents the most common home automation hardware bugs (like relay chatter and logic-level mismatches).

Pin Mapping & Wiring the 4-Channel Relay

The Songle 4-channel module is active-LOW. This means the relay engages when the GPIO pin is pulled to GND (0V), and disengages when the pin is HIGH (5V). We must account for this in both our physical wiring and our initialization code to prevent relays from violently chattering on boot.

1. Depower the system. Ensure the 5V supply and USB are disconnected.
2. Wire the logic. Connect D8 through D11 to IN1 through IN4 using 22 AWG solid wire.
3. Establish the common ground. Run a wire from the Arduino GND pin to the Relay Module GND pin. Without this shared reference, the opto-isolators will not trigger reliably.
4. Inject coil power. Connect your external 5V power supply positive to the Relay VCC, and the supply negative to the Relay GND.
5. Wire the mains side. (Warning: Mains voltage is lethal. If you are not comfortable wiring 120V/240V AC, stop here and use a pre-built smart plug). Connect your AC Live line to the relay COM (Common) terminal, and the NO (Normally Open) terminal to your load's Live input.

Complete MQTT Relay Control Code

This code targets the Arduino Uno R4 WiFi using the official WiFi library and the widely used PubSubClient library for MQTT. It includes non-blocking reconnect logic, payload validation, and safe active-LOW pin initialization.

#include <WiFi.h>
#include <PubSubClient.h>

// --- Pin Definitions (Active LOW Relays) ---
const int RELAY_1 = 8;
const int RELAY_2 = 9;
const int RELAY_3 = 10;
const int RELAY_4 = 11;
const int RELAY_PINS[4] = {RELAY_1, RELAY_2, RELAY_3, RELAY_4};

// --- Network & MQTT Configuration ---
const char* ssid = "YOUR_2_4GHZ_SSID";
const char* password = "YOUR_WIFI_PASSWORD";
const char* mqtt_server = "192.168.1.100"; // Local Mosquitto Broker IP
const int mqtt_port = 1883;
const char* mqtt_topic = "home/livingroom/relays";

WiFiClient espClient;
PubSubClient client(espClient);

void setup_wifi() {
  delay(10);
  Serial.print("Connecting to WiFi: ");
  Serial.println(ssid);
  WiFi.begin(ssid, password);
  
  int attempts = 0;
  while (WiFi.status() != WL_CONNECTED && attempts < 30) {
    delay(500);
    Serial.print(".");
    attempts++;
  }
  
  if (WiFi.status() == WL_CONNECTED) {
    Serial.println("\nWiFi connected. IP: ");
    Serial.println(WiFi.localIP());
  } else {
    Serial.println("\nWiFi connection failed. Rebooting...");
    ESP.restart(); // Fallback reset for ESP32-S3 bridge hang
  }
}

void callback(char* topic, byte* payload, unsigned int length) {
  // Error handling: Ignore malformed or empty payloads
  if (length < 2 || length > 10) return; 
  
  char msg[12];
  memcpy(msg, payload, length);
  msg[length] = '\0'; // Null-terminate
  
  // Expected format: "1_ON", "2_OFF", "ALL_ON"
  String command = String(msg);
  
  if (command.startsWith("ALL_")) {
    bool state = command.endsWith("ON") ? LOW : HIGH; // Active LOW
    for(int i=0; i<4; i++) digitalWrite(RELAY_PINS[i], state);
  } else {
    int relayNum = command.substring(0, 1).toInt();
    if (relayNum >= 1 && relayNum <= 4) {
      bool state = command.endsWith("ON") ? LOW : HIGH;
      digitalWrite(RELAY_PINS[relayNum - 1], state);
    }
  }
}

void reconnect() {
  while (!client.connected()) {
    Serial.print("Attempting MQTT connection...");
    String clientId = "UnoR4_Hub_" + String(random(0xffff), HEX);
    
    if (client.connect(clientId.c_str())) {
      Serial.println("connected");
      client.subscribe(mqtt_topic);
    } else {
      Serial.print("failed, rc=");
      Serial.print(client.state());
      Serial.println(" try again in 5 seconds");
      delay(5000);
    }
  }
}

void setup() {
  Serial.begin(115200);
  
  // Initialize relays as HIGH (OFF) BEFORE setting pinMode to prevent boot chatter
  for(int i=0; i<4; i++) {
    digitalWrite(RELAY_PINS[i], HIGH);
    pinMode(RELAY_PINS[i], OUTPUT);
  }
  
  setup_wifi();
  client.setServer(mqtt_server, mqtt_port);
  client.setCallback(callback);
  client.setBufferSize(512); // Prevent buffer overflow on large MQTT payloads
}

void loop() {
  if (!client.connected()) {
    reconnect();
  }
  client.loop();
}

Debugging: Fixing "MQTT connection failed, rc=-2"

When running the serial monitor, the most common roadblock in Arduino home automation projects is seeing the exact error string: MQTT connection failed, rc=-2.

In the PubSubClient library, rc=-2 explicitly means the network connection to the broker was refused or timed out. It is not an authentication failure (which is rc=-4 or rc=-5). The Arduino successfully reached your router, but cannot reach the MQTT server.

The First Three Things to Check:

1. Check Mosquitto Listener Binding: By default, modern Mosquitto (v2.0+) only binds to localhost (127.0.0.1) for security. Your Arduino is being rejected at the door. Open your mosquitto.conf file and explicitly add listener 1883 0.0.0.0 to allow LAN connections. See the Mosquitto config docs.
2. Verify IoT VLAN Routing: If your home network uses a dedicated IoT VLAN (e.g., 192.168.20.x) and your MQTT broker lives on your main LAN (192.168.1.x), your router's firewall is likely blocking port 1883 between subnets. Either move the broker to the IoT VLAN or add a specific firewall allow rule for TCP/1883.
3. Inspect the SSID Encoding: The ESP32-S3 WiFi bridge on the Uno R4 struggles with hidden SSIDs or SSIDs containing UTF-8 special characters (like emojis or accented letters). If your 2.4GHz network name has special characters, rename it to standard ASCII or create a dedicated IoT SSID.

Extending and Simplifying the Build

Once the core hub is online, you will inevitably want to scale it. Here is how to adapt this architecture based on your evolving home automation needs.

• To Simplify (No-Code Alternative): If writing C++ callbacks feels like overkill, swap the Arduino Uno R4 WiFi for an ESP8266 NodeMCU and flash it with ESPHome. ESPHome uses YAML configuration files and integrates natively with Home Assistant, eliminating the need to manage MQTT payloads and WiFi reconnection loops manually.
• To Extend (Add Sensors): The Uno R4 has a built-in 14-bit ADC (much more precise than the classic Uno's 10-bit). You can wire an LDR (Light Dependent Resistor) to A0 and a DHT22 temperature sensor to D2. Read these values in the loop() and publish them to a separate MQTT topic (e.g., home/livingroom/sensors) every 60 seconds using client.publish().
• To Extend (Add More Relays): If you need 8 or 16 channels, do not just wire more GPIO pins. You will run out of pins and exceed the microcontroller's current limits. Instead, use an MCP23017 I2C I/O Expander. It connects via just two wires (SDA/SCL) and gives you 16 additional GPIO pins to drive relay opto-isolators, managed via the Adafruit_MCP23X17 library.

By choosing a board with native 5V logic and separating the coil power from the logic power, you eliminate the physical layer failures that cause 90% of DIY smart home dropouts. Flash the code, publish an MQTT payload like 1_ON, and listen for the definitive click of a reliable home automation hub.