What Can You Do With a Raspberry Pi? 4 Practical Builds and Pinouts

When makers ask what can you do with a raspberry pi, the answer in 2026 spans everything from low-power remote IoT sensor nodes to edge-AI security camera servers. The Raspberry Pi ecosystem has matured far beyond simple desktop replacements. With the introduction of the PCIe-equipped Pi 5 and the continued dominance of the Pi Zero 2 W for headless deployments, choosing the right board and interfacing it with real-world hardware is the core challenge.

Rather than listing abstract ideas, this guide grounds the possibilities in silicon and code. We will map the current board lineup to specific use cases, walk through a complete I2C environmental monitor build with exact pinouts, and debug the most common hardware interface failure you will encounter on the bench.

Raspberry Pi Model Matrix: Which Board for Which Job?

Before wiring up sensors, you must match the compute module to the workload. Over-provisioning a simple MQTT sensor node with a Pi 5 wastes power and money, while under-provisioning a Frigate NVR setup with a Pi Zero 2 W will result in dropped frames and kernel panics. Below is the data-dense specification matrix for the current single-board computer (SBC) lineup.

Build: I2C Environmental Monitor (BME280)

To demonstrate practical hardware interfacing, we will build an environmental monitor that reads temperature, humidity, and barometric pressure. This project targets the Raspberry Pi 4 Model B (4GB) running Raspberry Pi OS (64-bit, Bookworm), though the code and pinouts are 100% compatible with the Pi 5 and Pi Zero 2 W.

Parts List

• Compute: Raspberry Pi 4 Model B (4GB RAM)
• Sensor: Adafruit BME280 I2C/SPI Breakout (Product ID: 2652)
• Wiring: STEMMA QT / Qwiic JST SH 4-pin cables (or standard 28 AWG Dupont jumpers)
• Storage: 16GB SanDisk Extreme A2 U3 MicroSD
• Power: Official Raspberry Pi 27W USB-C Power Supply (5.1V / 3A)

Pin Mapping Table

The Pi's hardware I2C bus 1 operates at 3.3V logic. Never connect 5V I2C devices directly to these pins without a level shifter, or you will fry the BCM2711 SoC's GPIO bank.

Complete Python Implementation

Before running the code, enable the I2C interface via sudo raspi-config (Interface Options > I2C > Enable) and install the SMBus library: sudo apt install python3-smbus2.

#!/usr/bin/env python3
"""
BME280 I2C Environmental Monitor
Target Board: Raspberry Pi 4 Model B / Pi 5
Dependencies: python3-smbus2
"""

import smbus2
import time
import sys

# --- PIN & BUS DEFINITIONS ---
I2C_BUS_NUMBER = 1        # Hardware I2C bus 1 (GPIO 2/3)
BME280_I2C_ADDR = 0x77    # Adafruit breakouts default to 0x77 (Generic modules often use 0x76)

# BME280 Registers for forced mode read
REG_DIG_T1 = 0x88
REG_CTRL_HUM = 0xF2
REG_CTRL_MEAS = 0xF4
REG_PRESS_MSB = 0xF7

def setup_sensor(bus):
    """Initialize the BME280 into forced mode for single-shot reads."""
    try:
        # Set humidity oversampling to x1
        bus.write_byte_data(BME280_I2C_ADDR, REG_CTRL_HUM, 0x01)
        # Set temp/pressure oversampling to x1, mode to forced (01)
        bus.write_byte_data(BME280_I2C_ADDR, REG_CTRL_MEAS, 0x25)
    except OSError as e:
        print(f"[CRITICAL] Failed to initialize sensor at 0x{BME280_I2C_ADDR:02X}: {e}")
        sys.exit(1)

def read_raw_data(bus):
    """Read raw bytes from the sensor registers."""
    try:
        # Read 8 bytes starting from pressure MSB (0xF7 covers press, temp, hum)
        data = bus.read_i2c_block_data(BME280_I2C_ADDR, REG_PRESS_MSB, 8)
        return data
    except OSError as e:
        # This is the exact error thrown when the Pi cannot ACK the I2C address
        raise OSError(f"I2C Read Failed: {e}")

def main():
    print(f"Initializing I2C Bus {I2C_BUS_NUMBER}...")
    with smbus2.SMBus(I2C_BUS_NUMBER) as bus:
        setup_sensor(bus)
        
        print("Starting environmental monitor loop. Press Ctrl+C to exit.")
        while True:
            try:
                # Trigger a new forced read
                bus.write_byte_data(BME280_I2C_ADDR, REG_CTRL_MEAS, 0x25)
                time.sleep(0.1) # Wait for measurement to complete
                
                raw = read_raw_data(bus)
                
                # Basic extraction (skipping full compensation math for brevity, 
                # but demonstrating successful I2C block reads)
                press_raw = (raw[0] << 12) | (raw[1] << 4) | (raw[2] >> 4)
                temp_raw = (raw[3] << 12) | (raw[4] << 4) | (raw[5] >> 4)
                hum_raw = (raw[6] << 8) | raw[7]
                
                print(f"Raw ADC -> Temp: {temp_raw}, Press: {press_raw}, Hum: {hum_raw}")
                time.sleep(2.0)
                
            except OSError as e:
                print(f"[ERROR] Bus communication fault: {e}. Check wiring.")
                time.sleep(5.0) # Backoff before retrying
            except KeyboardInterrupt:
                print("\nMonitor stopped by user.")
                break

if __name__ == "__main__":
    main()

Debugging: Fixing "Remote I/O error" on the I2C Bus

When working with the Pi's GPIO header, you will inevitably encounter the dreaded I2C bus fault. If your script crashes and outputs the exact error string OSError: [Errno 121] Remote I/O error, it means the Linux kernel's I2C driver sent a clock pulse on the SDA line but never received an Acknowledge (ACK) bit back from the sensor.

Here are the first three things to check when this failure occurs, ranked from most to least likely:

1. Verify I2C is enabled at the OS level: The Pi ships with I2C disabled by default to save a microscopic amount of power and prevent bus conflicts. Run sudo raspi-config, navigate to Interface Options, and enable I2C. A reboot is mandatory after this change.
2. Confirm the I2C address with i2cdetect: Run sudo i2cdetect -y 1 in the terminal. You should see a grid output with 77 (or 76) highlighted. If the grid is entirely empty (only dashes), your wiring is wrong or the sensor is dead. If you see UU, another driver has already claimed the device.
3. Check for SDA/SCL crossover: It is incredibly common to swap GPIO 2 (SDA) and GPIO 3 (SCL). Unlike UART, I2C will not simply fail silently if swapped; it will actively pull the bus low and throw the Errno 121 fault. Swap the blue and yellow wires and re-run i2cdetect.

Ranked Causes for Intermittent I/O Errors

If the code runs fine for an hour and then suddenly throws [Errno 121], you are dealing with signal integrity, not a configuration error.

Extending and Simplifying Your Pi Projects

Once the baseline I2C monitor is stable, you have two distinct paths for modifying the build based on your deployment environment.

How to Simplify: Drop to the Pi Zero 2 W

If this node is going inside an outdoor weatherproof enclosure (like a Stevenson screen) powered by a solar panel and a 12V LiFePO4 battery, the Pi 4 Model B is overkill. Swap the compute module for a Raspberry Pi Zero 2 W. The Python code above requires zero modifications because the BCM pin mapping for I2C bus 1 (GPIO 2/3) is identical across all Raspberry Pi SBCs.

The catch: The Zero 2 W uses a Micro-USB connector for power and requires a 5V/1.2A supply. You must ensure your solar charge controller's 5V buck converter is rated for at least 1.5A to handle the Zero's transient Wi-Fi transmission spikes, which can briefly pull 1.2A.

How to Extend: Integrate MQTT for Home Assistant

Printing raw ADC values to a local terminal is useless for a smart home. To extend this build, integrate the paho-mqtt library. Instead of the print() statement in the while True loop, format the compensated sensor data into a JSON payload and publish it to your broker:

import json
import paho.mqtt.client as mqtt

# MQTT Configuration
BROKER_IP = "192.168.1.50"
MQTT_TOPIC = "homeassistant/sensor/workshop/environment"

client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2)
client.connect(BROKER_IP, 1883, 60)

# Inside your loop, after calculating real values:
payload = json.dumps({"temp_c": 22.4, "humidity": 45.1, "pressure_hpa": 1013.2})
client.publish(MQTT_TOPIC, payload, qos=1, retain=True)

By setting retain=True and using a QoS of 1, you ensure that if your Home Assistant server reboots, it immediately receives the last known good state of the workshop environment without waiting for the Pi's next 2-second polling cycle. This architecture transforms a simple bench test into a robust, production-ready IoT node.

For deeper dives into I2C electrical specifications and official board schematics, refer to the Raspberry Pi Hardware Documentation and the Adafruit BME280 Wiring Guide.