5 Practical Projects with Raspberry Pi Zero 2 W: Build an MQTT Environmental Logger

If you are planning projects with Raspberry Pi Zero boards in 2026, the first hurdle is picking the right silicon. The original Pi Zero is a fantastic low-power board, but its single-core 1GHz ARM11 processor bottlenecks heavily when running modern Python libraries for MQTT, TLS encryption, and sensor polling simultaneously. For networked sensor projects, you need the quad-core upgrade.

Which Raspberry Pi Zero Variant Should You Actually Buy?

Before buying parts, run your project requirements through this decision matrix. The goal is to match the compute and power envelope to the workload without overspending or under-provisioning.

Parts List and Pin Mapping for the BME280 MQTT Logger

This build creates a low-power environmental node that reads temperature, humidity, and barometric pressure, then publishes the payload to an MQTT broker every 60 seconds. This is the foundational architecture for smart home climate control or greenhouse monitoring.

Exact Bill of Materials

• Compute: Raspberry Pi Zero 2 W (Board variant: Rev 1.0, 512MB LPDDR2)
• Sensor: BME280 I2C Breakout (Adafruit 2652 or generic 3.3V tolerant module)
• Power: 18650 UPS HAT (e.g., Geekworm X728 or generic 5V/3A output UPS) with protected 18650 Li-ion cells
• Storage: 16GB Samsung EVO Plus microSD (A2 rated for better random I/O)
• Wiring: 4x Female-to-Female Dupont jumper wires (22 AWG silicone)

Hardware Pin Mapping

The BME280 uses the hardware I2C bus. Do not use software bit-banging for I2C on the Pi Zero; it wastes CPU cycles and causes clock-stretching timeouts. Wire the sensor exactly as follows:

Step-by-Step Build and Python MQTT Script

1. Flash the OS: Use Raspberry Pi Imager to flash Raspberry Pi OS Lite (64-bit). In the advanced settings (Ctrl+Shift+X), enable SSH, set your WiFi credentials, and enable the I2C interface under Services.
2. Install Dependencies: SSH into the Pi and install the required Python packages. We use smbus2 for hardware I2C and paho-mqtt for the broker connection.
   sudo apt update && sudo apt install python3-pip python3-smbus i2c-tools -y
pip3 install paho-mqtt smbus2 RPi.bme280 --break-system-packages
3. Verify I2C Hardware: Run i2cdetect -y 1. You should see 76 or 77 in the grid. If the grid is empty, check your wiring.
4. Deploy the Script: Create a file named env_logger.py and paste the complete code below.

import time
import sys
import json
import smbus2
import bme280
import paho.mqtt.client as mqtt

# --- PIN & CONFIG DEFINITIONS ---
# Hardware I2C Pins on Pi Zero 2 W:
# SDA: Physical Pin 3 (GPIO 2)
# SCL: Physical Pin 5 (GPIO 3)
I2C_PORT = 1
BME280_ADDR = 0x76  # Change to 0x77 if i2cdetect shows 77
MQTT_BROKER = '192.168.1.50'
MQTT_PORT = 1883
MQTT_TOPIC = 'sensor/office/environment'
POLL_INTERVAL_SEC = 60

# Initialize I2C Bus and Sensor
def init_sensor():
    bus = smbus2.SMBus(I2C_PORT)
    # Load calibration parameters from the sensor's non-volatile memory
    calibration_params = bme280.load_calibration_params(bus, BME280_ADDR)
    return bus, calibration_params

# MQTT Callbacks for connection tracking
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():
    try:
        bus, cal_params = init_sensor()
    except FileNotFoundError:
        print('FATAL: I2C interface not enabled. Run raspi-config.')
        sys.exit(1)
    except OSError as e:
        print(f'FATAL: Hardware I2C error on address {hex(BME280_ADDR)}. Check wiring. ({e})')
        sys.exit(1)

    # Setup MQTT Client (Paho v2.0 API syntax)
    client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2, client_id='pi_zero_env_01')
    client.on_connect = on_connect
    
    try:
        client.connect(MQTT_BROKER, MQTT_PORT, keepalive=60)
        client.loop_start()
    except Exception as e:
        print(f'FATAL: Could not connect to MQTT broker at {MQTT_BROKER}. ({e})')
        sys.exit(1)

    print(f'Logging to {MQTT_TOPIC} every {POLL_INTERVAL_SEC}s...')
    
    try:
        while True:
            # Read sensor data
            data = bme280.sample(bus, BME280_ADDR, cal_params)
            
            # Build JSON payload
            payload = {
                'temp_c': round(data.temperature, 2),
                'humidity': round(data.humidity, 2),
                'pressure_hpa': round(data.pressure, 2),
                'timestamp': int(time.time())
            }
            
            # Publish to broker
            result = client.publish(MQTT_TOPIC, json.dumps(payload), qos=1)
            if result.rc != mqtt.MQTT_ERR_SUCCESS:
                print(f'MQTT Publish failed: {result.rc}')
            else:
                print(f'Published: {payload}')
                
            time.sleep(POLL_INTERVAL_SEC)
            
    except KeyboardInterrupt:
        print('Stopping logger...')
    finally:
        client.loop_stop()
        client.disconnect()

if __name__ == '__main__':
    main()

To run it persistently in the background, create a systemd service rather than using nohup or screen. This ensures the script restarts automatically if the Pi Zero 2 W suffers a brownout and reboots.

Debugging: Fixing "OSError: [Errno 121] Remote I/O error"

When working with I2C on the Pi Zero, you will inevitably hit this exact error string:

OSError: [Errno 121] Remote I/O error

This is a low-level kernel error indicating the BCM2835 I2C controller sent a clock pulse but received no acknowledgment (ACK) from the slave device. Here is the ranked decision path to fix it, from most to least likely.

The First Three Things to Check

1. Wrong I2C Address (80% of cases): The BME280 has two possible addresses: 0x76 and 0x77. Adafruit boards default to 0x77; most cheap Amazon/AliExpress breakouts default to 0x76. Run i2cdetect -y 1. If you see 77, change BME280_ADDR = 0x76 to 0x77 in the Python script.
2. I2C Disabled in Device Tree (15% of cases): If i2cdetect returns an error or shows a completely blank grid, the hardware bus is disabled. Run sudo raspi-config, navigate to Interface Options -> I2C, enable it, and reboot.
3. Loose Dupont Wire on SDA/SCL (5% of cases): The Pi Zero 2 W requires you to solder the 40-pin header yourself. If your solder joints on Pin 3 or Pin 5 are cold, or if the female Dupont connectors are stretched out, the bus will drop packets. Measure continuity from the Pi header to the sensor breakout with a multimeter (should read < 1 ohm).

Extending or Simplifying the Build

Once the baseline logger is stable, you can scale the project up or down based on your deployment environment.

How to Simplify (Lower Power / Lower Cost)

• Drop MQTT for Local Logging: If you don't need real-time alerts, remove the paho-mqtt library and write the JSON payload directly to a local CSV file on the SD card. This allows you to disable the WiFi radio entirely (sudo rfkill block wifi), dropping the Pi Zero 2 W idle power draw from ~0.6W down to ~0.25W, extending 18650 battery life by weeks.
• Switch to Deep Sleep: The Pi Zero doesn't have native hardware deep sleep like an ESP32. To achieve micro-amp sleep currents, add a hardware timer like the Adafruit TPL5110 to physically cut power to the Pi between readings.

How to Extend (Higher Capability)

• Add TLS Encryption: If publishing to a cloud broker (like AWS IoT or HiveMQ), you must secure the connection. Generate client certificates and update the Paho MQTT client configuration: client.tls_set(ca_certs='ca.pem', certfile='client.pem', keyfile='client.key'). The Zero 2 W's quad-core Cortex-A53 handles the TLS handshake in milliseconds, whereas the original Zero W would stall for seconds.
• Add a Local Dashboard: Install InfluxDB and Grafana directly on the Pi Zero 2 W. The 512MB RAM is tight for modern Grafana, so allocate a 1GB swap file (sudo dphys-swapfile swapoff, edit CONF_SWAPSIZE=1024, then sudo dphys-swapfile swapon) to prevent the OOM killer from terminating your database during heavy queries.

By targeting the exact hardware capabilities of the Zero 2 W and handling I2C exceptions gracefully in Python, you eliminate the most common failure points in embedded environmental logging. Wire it cleanly, verify the I2C address, and let the systemd service handle the rest.