Arduino or Raspberry Pi for IoT? Building a Distributed MQTT Sensor Hub

Settling the Arduino or Raspberry Pi Debate for IoT

When makers search for "Arduino or Raspberry Pi" for home automation, they are usually asking the wrong question. The assumption is that you must pick one to rule your entire stack. In reality, professional IoT architectures in 2026 rely on distributed computing: using a Raspberry Pi as the high-power edge broker and dashboard, while deploying Arduinos as low-power, real-time sensor nodes.

This guide walks you through building a dual-protocol MQTT sensor hub. We will use a Raspberry Pi 4 Model B running Eclipse Mosquitto as the local MQTT broker, and an Arduino Nano RP2040 Connect as the remote Wi-Fi sensor node reading environmental data. This combination gives you the Linux-based processing power of the Pi alongside the deterministic, low-level hardware control of the Arduino.

System Architecture and Component Specifications

Before cutting wires, you need to understand the power and data flow. The Raspberry Pi stays powered 24/7, managing message routing and data logging. The Arduino node polls the sensor, connects to Wi-Fi, publishes the payload, and can optionally sleep to conserve power.

Note: The Arduino Nano RP2040 Connect operates at 3.3V logic. The Adafruit BME280 breakout also operates at 3.3V and has onboard pull-ups, so you can wire them directly without a level shifter. The level shifter is only required if you substitute a 5V-tolerant sensor like the DHT22.

Wiring the Arduino Nano RP2040 Sensor Node

The Nano RP2040 Connect features a dual-core ARM Cortex-M0+ and a u-blox NINA-W10 Wi-Fi module. Crucially, it has separate I2C buses: one internal (for the onboard IMU and microphone) and one external on the header pins. We will use the external I2C bus for the BME280.

Pin Mapping Table

Physical Assembly Steps

1. Prep the headers: Solder standard 0.1-inch male headers to the Arduino Nano RP2040 Connect if they aren't pre-installed. Mount it on a breadboard.
2. Wire Power: Connect a jumper from the Nano's 3V3 pin to the breadboard's positive rail, and GND to the negative rail. Connect the BME280 VIN and GND to these rails.
3. Wire I2C Data: Connect Nano pin A4 to BME280 SDA. Connect Nano pin A5 to BME280 SCL.
4. Verify Address: Ensure the SDO pin on the BME280 is unconnected (floating high via internal pull-up) so the sensor defaults to I2C address 0x77.

Firmware: Compilable C++ with Error Handling

Target Board Variant: This code is written specifically for the Arduino Nano RP2040 Connect using the official Arduino Mbed OS Nano RP2040 Boards core (version 2.8.0 or newer). It utilizes the onboard NINA-W10 Wi-Fi coprocessor via the WiFiNINA library.

Prerequisites: Install the WiFiNINA, ArduinoMqttClient, and Adafruit BME280 Library via the Arduino IDE Library Manager.

#include <SPI.h>
#include <WiFiNINA.h>
#include <ArduinoMqttClient.h>
#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BME280.h>

// --- NETWORK & MQTT CONFIGURATION ---
const char* ssid = "YOUR_WIFI_SSID";
const char* pass = "YOUR_WIFI_PASSWORD";
const char* mqtt_broker = "192.168.1.100"; // IP of your Raspberry Pi
const int mqtt_port = 1883;
const char* mqtt_topic = "home/livingroom/environment";

// --- HARDWARE INSTANCES ---
WiFiClient wifiClient;
MqttClient mqttClient(wifiClient);
Adafruit_BME280 bme;

// --- TIMING VARIABLES ---
unsigned long lastMillis = 0;
const long publishInterval = 15000; // Publish every 15 seconds

void setup() {
  Serial.begin(115200);
  while (!Serial) { delay(10); }
  Serial.println("--- Nano RP2040 MQTT Node Booting ---");

  // 1. Initialize I2C and BME280 Sensor
  if (!bme.begin(0x77)) {
    Serial.println("FATAL: Could not find a valid BME280 sensor, check wiring!");
    while (1) { delay(10); } // Halt execution
  }
  Serial.println("BME280 initialized on I2C 0x77.");

  // 2. Check for NINA Wi-Fi Module
  if (WiFi.status() == WL_NO_MODULE) {
    Serial.println("FATAL: Communication with WiFi module failed!");
    while (1) { delay(10); }
  }

  // 3. Connect to Wi-Fi
  Serial.print("Connecting to SSID: ");
  Serial.println(ssid);
  int status = WL_IDLE_STATUS;
  int retries = 0;
  while (status != WL_CONNECTED && retries < 10) {
    status = WiFi.begin(ssid, pass);
    delay(2000);
    retries++;
  }
  
  if (status != WL_CONNECTED) {
    Serial.println("ERROR: Failed to connect to Wi-Fi after 10 retries.");
  } else {
    Serial.print("Connected! IP: ");
    Serial.println(WiFi.localIP());
  }
}

void loop() {
  // Maintain Wi-Fi Connection
  if (WiFi.status() != WL_CONNECTED) {
    Serial.println("Wi-Fi dropped. Reconnecting...");
    WiFi.begin(ssid, pass);
    delay(5000);
    return; // Skip this loop iteration
  }

  // Maintain MQTT Connection
  if (!mqttClient.connected()) {
    Serial.print("Connecting to MQTT broker at ");
    Serial.print(mqtt_broker);
    Serial.print(":");
    Serial.println(mqtt_port);
    
    if (!mqttClient.connect(mqtt_broker, mqtt_port)) {
      Serial.print("MQTT connection failed! Error code = ");
      Serial.println(mqttClient.connectError());
      delay(5000);
      return;
    }
    Serial.println("MQTT Connected.");
  }

  // Poll MQTT client to keep connection alive
  mqttClient.poll();

  // Publish Sensor Data on Interval
  if (millis() - lastMillis > publishInterval) {
    lastMillis = millis();
    
    float tempC = bme.readTemperature();
    float humidity = bme.readHumidity();
    float pressure = bme.readPressure() / 100.0F;

    // Construct JSON payload
    String payload = "{\"temp_c\":" + String(tempC, 2) + 
                     ",\"hum_pct\":" + String(humidity, 1) + 
                     ",\"press_hpa\":" + String(pressure, 1) + "}";

    Serial.print("Publishing: ");
    Serial.println(payload);
    
    mqttClient.beginMessage(mqtt_topic);
    mqttClient.print(payload);
    mqttClient.endMessage();
  }
}

Debugging: First Three Things to Check When It Fails

Embedded Wi-Fi projects rarely work perfectly on the first compile. When your serial monitor spits out errors, follow this ranked decision tree. These are the three most common failure modes for the Nano RP2040 Connect and NINA module architecture.

1. Error: MQTT connection failed! Error code = -2

What it means: The ArduinoMqttClient library returns -2 (LWMQTT_NETWORK_FAILED_CONNECT) when the TCP socket cannot be established. The Wi-Fi is connected, but the broker is rejecting or ignoring the handshake.

• Cause A (Most Likely): Mosquitto on your Raspberry Pi is configured to only accept local connections.
  Fix: Edit /etc/mosquitto/mosquitto.conf on the Pi, add listener 1883 and allow_anonymous true, then restart the service (sudo systemctl restart mosquitto).
• Cause B: You are targeting port 8883 (TLS) in the code, but the broker expects 1883 (plaintext).
  Fix: Ensure mqtt_port in the C++ code matches your Mosquitto listener configuration.

2. Error: WiFiNINA: Firmware upgrade required or FATAL: Communication with WiFi module failed!

What it means: The NINA-W10 coprocessor firmware version flashed at the factory is older than the minimum version demanded by the WiFiNINA Arduino library you installed.

• Cause: Library/Firmware mismatch. Adafruit and Arduino frequently update the NINA firmware to patch WPA2 vulnerabilities.
• Fix: Open the Arduino IDE. Go to Tools > WiFi101 / WiFiNINA Firmware Updater. Select your Nano RP2040 Connect port, click "Check Updates", and flash the latest NINA firmware binary. This takes about 60 seconds and permanently resolves the error.

3. Error: Could not find a valid BME280 sensor, check wiring!

What it means: The Wire library sent an I2C scan to address 0x77 and received no ACK (acknowledge) bit back from the sensor.

• Cause A: I2C address mismatch. Some cheap BME280 clones from Amazon/AliExpress hardwire the SDO pin to GND, making the address 0x76.
  Fix: Change bme.begin(0x77) to bme.begin(0x76) in the code.
• Cause B: You accidentally wired the sensor to the internal I2C pins or swapped SDA/SCL.
  Fix: Verify SDA is on A4 and SCL is on A5. Run an I2C scanner sketch to verify the bus is active.

Extending and Simplifying the Build

Once you have the base hub running, you will inevitably want to tweak the architecture to fit your specific budget or deployment environment.

How to Simplify (The Budget Route)

If the $22 price tag of the Nano RP2040 Connect is too high for deploying 10+ nodes around your house, swap the microcontroller for an ESP32-WROOM-32 DevKit (typically $6 to $8).

• Code Changes: Replace #include <WiFiNINA.h> with the native #include <WiFi.h>. The ESP32 handles Wi-Fi natively in the main SoC, eliminating the need for the NINA coprocessor and firmware updater tools.
• Trade-off: You lose the RP2040's hardware crypto chip (ATECC608) and the ultra-low deep sleep current of the M0+ architecture, but you gain raw processing power and a much lower BOM cost.

How to Extend (The Pro Route)

To make this system production-ready for a smart home, implement these two upgrades:

1. Add TLS Encryption: The Nano RP2040 Connect includes an ATECC608 crypto-authentication chip. You can use the ArduinoECCX08 library to generate self-signed certificates and connect to your Raspberry Pi Mosquitto broker over port 8883 (MQTTS), preventing payload sniffing on your local network.
2. Integrate Home Assistant: Instead of just logging to a terminal, install Eclipse Mosquitto as an add-on inside Home Assistant OS on your Raspberry Pi. Configure the Home Assistant MQTT integration to automatically discover the home/livingroom/environment topic using the MQTT Discovery protocol, instantly generating dashboards without writing YAML.

By treating the "Arduino or Raspberry Pi" question as a hardware synergy problem rather than a binary choice, you build IoT networks that are both robust enough for 24/7 uptime and cheap enough to scale across every room in your home.