Practical Projects for Raspberry Pi Zero: Build an MQTT I2C Sensor Node

If you are scoping out projects for Raspberry Pi Zero boards in 2026, the very first decision you need to make is hardware selection. The original Pi Zero V1.3 and Zero W V1.1 are fundamentally obsolete for new embedded deployments due to their single-core 1GHz ARM11 processors and 512MB RAM limits, which bottleneck modern Python libraries and TLS-encrypted MQTT connections. For any new build, the Raspberry Pi Zero 2 W (quad-core Cortex-A53, 512MB LPDDR2) is the baseline.

In this guide, we are building a headless, low-power I2C environmental data logger that reads temperature and humidity from a Sensirion SHT31 sensor and publishes the payload to an MQTT broker. This project covers raw I2C byte manipulation, network resilience, and headless debugging.

The 2026 Decision Matrix: Which Pi Zero Variant Do You Actually Need?

Before ordering parts, run your project requirements through this decision path. Do not default to the cheapest board if your software stack requires multi-threading.

Concrete Pick: For this MQTT sensor node, buy the Raspberry Pi Zero 2 W with pre-soldered headers (Part number: SC0510 / Adafruit 5291). It saves you 20 minutes of fragile SMD header soldering and costs roughly $20.

Project Build: I2C Environmental Logger with MQTT Uplink

Parts List

• Compute: Raspberry Pi Zero 2 W (SC0510) with pre-soldered 40-pin header.
• Sensor: Sensirion SHT31-D Breakout (Adafruit 2857 or equivalent). Note: Do not use the cheaper DHT11/DHT22; they use bit-banged 1-Wire protocols that are unreliable on Linux due to kernel scheduling jitter.
• Power: 5V 2.5A Micro-USB Power Supply (CanaKit or official Pi PSU). The Zero 2 W will brownout on standard 1A phone chargers when the WiFi radio transmits.
• Wiring: 4x Female-to-Female jumper wires (22 AWG silicone).
• Storage: 32GB microSD card (Samsung EVO Select or SanDisk Extreme) flashed with Raspberry Pi OS Lite (64-bit).

Wiring and Pin Mapping

The Raspberry Pi Zero 2 W exposes two hardware I2C buses. We use I2C1 (Bus 1) on the primary GPIO header. The SHT31 breakout includes onboard 10kΩ pull-up resistors, so we do not need to add external resistors to the SDA/SCL lines.

1. Flash Pi OS Lite (64-bit) using Raspberry Pi Imager. In the OS Customization menu, enable SSH, set your WiFi credentials, and set the hostname to sensor-node-01.
2. Insert the SD card and power on the Pi. SSH into the board: ssh youruser@sensor-node-01.local.
3. Enable the I2C interface: Run sudo raspi-config, navigate to Interface Options > I2C, and enable it. Reboot.
4. Verify the sensor is visible on the bus: Run sudo i2cdetect -y 1. You should see 44 in the grid (the default I2C address for the SHT31).
5. Install dependencies: sudo apt update && sudo apt install python3-pip python3-smbus2 python3-paho-mqtt -y.

Complete Python Implementation (Target: Pi Zero 2 W)

This script uses smbus2 for raw I2C communication and paho-mqtt for the network uplink. It avoids heavy abstraction libraries, keeping the memory footprint under 15MB—critical for the 512MB Zero 2 W.

#!/usr/bin/env python3
import time
import json
import sys
from smbus2 import SMBus, i2c_msg
import paho.mqtt.client as mqtt

# --- PIN & HARDWARE DEFINITIONS ---
I2C_BUS_ID = 1          # Physical pins 3 (SDA) and 5 (SCL)
SHT31_ADDR = 0x44       # Default I2C address (ADDR pin tied to GND)
MQTT_BROKER = '192.168.1.50'
MQTT_PORT = 1883
MQTT_TOPIC = 'home/lab/environment'
POLL_INTERVAL_SEC = 60

def read_sht31():
    """Reads temp and humidity via raw I2C high-repeatability command."""
    with SMBus(I2C_BUS_ID) as bus:
        # Send measurement command: 0x2C (high repeatability), 0x06
        write_msg = i2c_msg.write(SHT31_ADDR, [0x2C, 0x06])
        bus.i2c_rdwr(write_msg)
        
        time.sleep(0.020) # Wait 20ms for sensor to process
        
        # Read 6 bytes: [Temp MSB, Temp LSB, CRC, Hum MSB, Hum LSB, CRC]
        read_msg = i2c_msg.read(SHT31_ADDR, 6)
        bus.i2c_rdwr(read_msg)
        data = list(read_msg)
        
        # Calculate Temperature (Celsius)
        raw_temp = (data[0] << 8) | data[1]
        temp_c = -45 + (175 * (raw_temp / 65535.0))
        
        # Calculate Relative Humidity (%)
        raw_hum = (data[3] << 8) | data[4]
        hum_pct = 100 * (raw_hum / 65535.0)
        
        return round(temp_c, 2), round(hum_pct, 2)

def on_connect(client, userdata, flags, rc, properties=None):
    if rc == 0:
        print('Connected to MQTT Broker')
    else:
        print(f'MQTT Connection failed with code {rc}')

def main():
    client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2, client_id='pi_zero_node_01')
    client.on_connect = on_connect
    
    try:
        client.connect(MQTT_BROKER, MQTT_PORT, keepalive=120)
        client.loop_start()
    except ConnectionRefusedError:
        print(f'FATAL: MQTT Broker at {MQTT_BROKER} refused connection.')
        sys.exit(1)
    except Exception as e:
        print(f'FATAL: Network error: {e}')
        sys.exit(1)

    print(f'Starting sensor loop. Publishing to {MQTT_TOPIC} every {POLL_INTERVAL_SEC}s.')
    
    while True:
        try:
            temp, hum = read_sht31()
            payload = json.dumps({'temp_c': temp, 'humidity_pct': hum, 'node': 'pi_zero_01'})
            client.publish(MQTT_TOPIC, payload, qos=1)
            print(f'Published: {payload}')
        except OSError as e:
            # Catches I2C bus failures (e.g., [Errno 121] Remote I/O error)
            print(f'I2C Read Error: {e}. Check wiring.')
        except Exception as e:
            print(f'Unexpected error: {e}')
            
        time.sleep(POLL_INTERVAL_SEC)

if __name__ == '__main__':
    main()

Debugging: First Three Checks and the 'Remote I/O' Error

When working with bare-metal I2C on Linux, the most common failure mode is the kernel throwing an I/O error when the ioctl system call fails to get an ACK from the sensor.

The Exact Error String:
OSError: [Errno 121] Remote I/O error

If your script crashes with this string, or if i2cdetect shows a blank grid, execute these first three checks in order:

1. Verify I2C is actually enabled in the kernel: Open /boot/firmware/config.txt (or /boot/config.txt on older OS versions) and ensure the line dtparam=i2c_arm=on is present and not commented out. A reboot is required after changing this.
2. Check Physical Continuity and Voltage: Use a multimeter to verify 3.3V between the VIN and GND pins on the sensor breakout. Then, measure the SDA and SCL lines relative to GND; they should read ~3.3V due to the pull-up resistors. If they read 0V, your Pi's GPIO pins are not driving the bus, or the sensor's pull-ups are missing/broken.
3. Verify the I2C Address: Sensirion SHT31 sensors can be ordered with address 0x44 or 0x45 depending on the state of the ADDR pin. Run i2cdetect -y 1. If you see 45 instead of 44, update the SHT31_ADDR constant in the Python script.

Scaling the Build: Simplify or Extend

Once the baseline MQTT node is stable, you need to decide how to adapt it for your specific deployment environment. Here is the concrete path forward based on your infrastructure.

How to Simplify (No Network Infrastructure)

If you do not have an MQTT broker running and just want to log data for a school project or local analysis, strip out the paho-mqtt dependency entirely. Replace the client.publish() block with a standard Python CSV writer:

import csv
with open('/var/log/sensor_data.csv', 'a', newline='') as f:
    writer = csv.writer(f)
    writer.writerow([time.time(), temp, hum])

This reduces the script's memory footprint to under 8MB and eliminates all network-related crash vectors.

How to Extend (Off-Grid / Solar Deployment)

The Pi Zero 2 W idles around 120mA and spikes to 350mA under WiFi load. A standard 2000mAh USB power bank will die in less than 10 hours. To make this a true remote embedded node:

• Add a PiJuice Zero HAT: This stacks directly on the GPIO header, adding a 1820mAh LiPo battery, a solar charge controller, and an RTC (Real Time Clock). The RTC is critical because the Pi Zero loses time when powered off, which breaks TLS certificate validation.
• Implement Software Deep Sleep: Use the PiJuice API to schedule a wake-up alarm, then execute sudo shutdown -h now at the end of your Python script. This drops the power draw from 120mA to roughly 1mA between readings, extending a 6V 3W solar panel setup to run indefinitely.

For further reading on I2C electrical specifications and pull-up resistor calculations, refer to the NXP I2C-bus specification user manual. For Raspberry Pi hardware schematics and GPIO limits, consult the official Raspberry Pi documentation. For MQTT protocol standards and QoS levels, review the Eclipse Paho project.