Home Assistant Raspberry Pi 5 Build: NVMe Setup and ESP32 Node

The most reliable home assistant raspberry pi build in 2026 abandons microSD cards entirely. By pairing the Raspberry Pi 5 (8GB) with an NVMe SSD via its native PCIe 2.0 lane, you eliminate the database write-wear that causes 90% of Home Assistant OS crashes on older Pi models. This guide walks through the exact hardware selection for the Pi 5 server, followed by the schematic, pinout, and C++ firmware for a custom ESP32-C3 MQTT CO2 sensor node to feed data into your new dashboard.

Pi 4 vs Pi 5: Hardware Specs for Home Assistant

While the Pi 4 was the community standard for years, the Pi 5's I/O architecture fundamentally changes how Home Assistant handles database logging (InfluxDB/SQLite) and add-on compilation. Below is a data-dense comparison of the variants you will encounter when sourcing parts.

Parts List and Server Assembly

To build the server, you need components that support the Pi 5's 27W USB-C PD power requirement and its M.2 HAT ecosystem. Do not use Pi 4 power supplies; the Pi 5 will throttle the USB ports if it negotiates less than 5V/5A.

• Compute: Raspberry Pi 5 (8GB variant) - Required for running Frigate NVR or multiple ESPHome compilations simultaneously.
• Enclosure/Storage: Argon ONE V3 M.2 NVMe Raspberry Pi 5 Case. This routes the PCIe lane to an internal 2230 M.2 slot and provides passive cooling.
• Storage: Samsung 980 256GB NVMe M.2 2230 SSD. (Avoid DRAM-less QLC drives like the Crucial P3 for HA; the constant SQLite writes will exhaust their TBW rating in under 18 months).
• Power: Official Raspberry Pi 27W USB-C Power Supply.
• Zigbee Coordinator: Sonoff Zigbee 3.0 USB Dongle Plus (ZBDongle-P, CC2652P chipset).

For the environmental sensor node feeding the server:

• MCU: ESP32-C3 SuperMini (Single-core RISC-V, native USB-C, lower quiescent current than the ESP32-S3).
• Sensor: Sensirion SCD40 CO2, Temperature, and Humidity sensor breakout.

Wiring the ESP32-C3 Sensor Node

The code provided below targets the ESP32-C3 SuperMini variant. The SCD40 uses I2C. While the SCD40 breakout board typically includes 10kΩ pull-up resistors, if you are wiring a raw module, you must add 4.7kΩ pull-ups to SDA and SCL. The ESP32-C3's internal pull-ups are too weak (~45kΩ) for reliable 400kHz I2C communication over wires longer than 10cm.

Firmware Code and MQTT Integration

This C++ firmware is designed for the Arduino IDE (ensure you have the esp32 board package v2.0.14 or newer installed via Board Manager). It reads the SCD40 every 60 seconds and publishes the data as retained JSON payloads to an MQTT broker running as an add-on on your Home Assistant Raspberry Pi.

#include <WiFi.h>
#include <PubSubClient.h>
#include <Wire.h>
#include <SensirionI2CScd4x.h>
#include <ArduinoJson.h>

// --- PIN DEFINITIONS ---
#define PIN_SDA 6
#define PIN_SCL 7

// --- NETWORK & MQTT CONFIG ---
const char* ssid = "YourWiFiSSID";
const char* password = "YourWiFiPassword";
const char* mqtt_server = "192.168.1.50"; // Your Home Assistant Pi IP
const int mqtt_port = 1883;
const char* mqtt_user = "mqtt_user";
const char* mqtt_pass = "mqtt_password";
const char* mqtt_topic = "homeassistant/sensor/livingroom_co2/state";

WiFiClient espClient;
PubSubClient client(espClient);
SensirionI2CScd4x scd4x;

void setup_wifi() {
  delay(10);
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  
  int attempts = 0;
  while (WiFi.status() != WL_CONNECTED && attempts < 30) {
    delay(500);
    attempts++;
  }
  
  if (WiFi.status() != WL_CONNECTED) {
    Serial.println("ERROR: WiFi connection failed. Check SSID/Pass.");
    ESP.restart();
  }
}

void reconnect() {
  int retries = 0;
  while (!client.connected() && retries < 5) {
    String clientId = "ESP32C3-CO2-" + String(random(0xffff), HEX);
    if (client.connect(clientId.c_str(), mqtt_user, mqtt_pass)) {
      Serial.println("MQTT Connected");
    } else {
      Serial.print("MQTT failed, rc=");
      Serial.print(client.state());
      Serial.println(" retrying in 5s");
      delay(5000);
      retries++;
    }
  }
  if (!client.connected()) {
    Serial.println("MQTT connect failed after 5 retries. Restarting.");
    ESP.restart();
  }
}

void setup() {
  Serial.begin(115200);
  while (!Serial) { delay(100); }
  
  setup_wifi();
  client.setServer(mqtt_server, mqtt_port);
  
  Wire.begin(PIN_SDA, PIN_SCL);
  scd4x.begin(Wire);
  
  uint16_t error;
  char errorMessage[256];
  
  // Stop any potentially running low-power or periodic measurements before starting
  scd4x.stopPeriodicMeasurement();
  delay(500);
  
  error = scd4x.startPeriodicMeasurement();
  if (error) {
    Serial.print("SCD40 init failed: ");
    errorToString(error, errorMessage, 256);
    Serial.println(errorMessage);
  }
}

void loop() {
  if (!client.connected()) {
    reconnect();
  }
  client.loop();
  
  uint16_t error;
  char errorMessage[256];
  uint16_t co2 = 0;
  float temperature = 0.0f;
  float humidity = 0.0f;
  bool isDataReady = false;
  
  error = scd4x.getDataReadyFlag(isDataReady);
  if (error) { return; }
  
  if (isDataReady) {
    error = scd4x.readMeasurement(co2, temperature, humidity);
    if (error) {
      Serial.print("Read error: ");
      errorToString(error, errorMessage, 256);
      Serial.println(errorMessage);
    } else if (co2 > 0) {
      JsonDocument doc;
      doc["co2"] = co2;
      doc["temperature"] = round(temperature * 10.0) / 10.0;
      doc["humidity"] = round(humidity * 10.0) / 10.0;
      
      char buffer[256];
      serializeJson(doc, buffer);
      
      // Publish as retained so HA gets the last known state on reboot
      client.publish(mqtt_topic, buffer, true);
    }
  }
  
  // SCD40 updates every 5 seconds, but we only need to check/publish frequently
  delay(5000); 
}

Debugging: Boot Failures and MQTT Errors

When integrating custom nodes with a Home Assistant Raspberry Pi server, network and I2C handshakes are the primary failure points. Here is how to diagnose the most common errors.

Exact Error: MQTT failed, rc=-2

The rc=-2 state in PubSubClient translates to MQTT_CONNECTION_REFUSED. The ESP32 reached the Pi, but the broker rejected the handshake.

1. Check Mosquitto Add-on ACLs: In Home Assistant, go to Settings > Add-ons > Mosquitto Broker > Configuration. Ensure the logins array contains the exact mqtt_user and mqtt_pass defined in your code.
2. Verify Port Forwarding/Firewall: If your Pi is running UFW or a custom iptables rule via the SSH add-on, ensure port 1883 is open for the local subnet.
3. Check Broker Binding: Ensure Mosquitto is bound to 0.0.0.0 and not just 127.0.0.1 in its advanced configuration.

Exact Error: SCD40 init failed: I2C transfer failed

This occurs when the ESP32-C3 cannot pull the SDA line high during the acknowledgment phase.

1. First thing to check: Measure the voltage on the SDA and SCL pins with a multimeter. Both should read ~3.2V to 3.3V when idle. If they read near 0V, you are missing pull-up resistors.
2. Second thing to check: The SCD40 requires up to 150mA peak during the measurement phase. If powering from the Pi's 3.3V rail via a long breadboard, voltage drop will brownout the sensor. Power the SCD40 VIN from the ESP32-C3's 5V pin (if the breakout has an onboard LDO) or use a dedicated 3.3V LDO like the AMS1117-3.3.
3. Third thing to check: Wire continuity. The ESP32-C3 SuperMini's GPIO 6 and 7 are adjacent to the 5V pin; a slight breadboard misalignment will short SDA to VCC.

Extending or Simplifying the Build

Depending on your maintenance tolerance, you can scale this architecture up or down.

How to Simplify: Switch to ESPHome

If writing raw C++ and managing JSON payloads feels like overhead, replace the Arduino IDE code with ESPHome. ESPHome integrates natively with Home Assistant via the ESPHome Dashboard add-on. The YAML configuration for the SCD40 is simply:

sensor:
  - platform: scd4x
    co2:
      name: "Living Room CO2"
    temperature:
      name: "Living Room Temperature"
    humidity:
      name: "Living Room Humidity"
    update_interval: 60s

This eliminates the need for a separate MQTT broker configuration for this specific node, as ESPHome uses the native Home Assistant API.

How to Extend: Add a Local Voice Satellite

The Pi 5's 8GB RAM and Cortex-A76 cores can handle local wake-word detection. You can extend this setup by plugging a Raspberry Pi ReSpeaker 2-Mics Pi HAT (or a USB conference mic) into the Pi 5, and installing the wyoming-faster-whisper and wyoming-openwakeword add-ons. This allows your Home Assistant Raspberry Pi to act as both the central server and a local voice satellite, keeping all voice processing completely off the cloud and reducing latency to under 400ms on the local network.

By anchoring your smart home on an NVMe-backed Pi 5 and feeding it with robust, error-handled ESP32 sensor nodes, you create a topology that survives power blips, SD card rot, and network hiccups without requiring constant manual intervention.