What Are Raspberry Pi Used For? 5 Embedded Projects and I2C Debugging Guide

When makers ask what are Raspberry Pi used for, the casual answer is usually 'a cheap desktop computer.' But on the workbench and in industrial enclosures, the Raspberry Pi ecosystem serves a very different purpose: it is the bridge between bare-metal microcontrollers (like the ESP32) and full x86 server infrastructure. In 2026, the Pi is the undisputed king of headless Linux edge-compute, local IoT gateways, and hardware-in-the-loop prototyping.

Unlike a microcontroller that runs a single loop, a Raspberry Pi runs a full OS, allowing you to host databases, run Docker containers, execute complex Python libraries, and manage local network traffic—all while exposing physical GPIO pins to the real world. Below, we map out the core embedded use cases, then dive into a concrete hardware build and debug the most common I2C bus failures you will encounter.

Raspberry Pi Embedded Use Cases & Hardware Matrix

Choosing the wrong board variant is the most common reason embedded Pi projects fail or overheat. The table below maps real-world embedded applications to the specific 2026 hardware variants, power requirements, and primary interfaces needed for the job.

Note: Power draws assume a headless Linux environment with WiFi enabled and moderate CPU load. Always size your 5V buck converters or wall adapters with at least a 30% overhead to prevent brownouts during peripheral spin-up.

Deep Dive Build: I2C Environmental Sensor Node

To demonstrate the Pi's role as a low-power sensor node, we will build an environmental monitoring rig. This project targets the Raspberry Pi Zero 2 W, reading temperature, humidity, and barometric pressure from a Bosch BME280 sensor via the I2C bus, and logging it locally.

Parts List

• Compute: Raspberry Pi Zero 2 W (with pre-soldered 40-pin male header)
• Sensor: Adafruit BME280 I2C/SPI Breakout (Product ID: 2652) — Do not use generic 'BMP280' clones if you need humidity.
• Storage: 16GB SanDisk Extreme A2 Application Performance microSD card
• Wiring: 4x Female-to-Female Dupont jumper wires (24 AWG)
• Power: High-quality 5V / 2.5A Micro-USB power supply (The Zero 2 W uses Micro-USB for power, not USB-C)

Pin Mapping Table

The Raspberry Pi I2C bus operates at 3.3V logic. The Adafruit BME280 breakout includes onboard 3.3V voltage regulation and 10kΩ pull-up resistors, making it safe to wire directly to the Pi's 40-pin header. Reference Pinout.xyz for visual confirmation.

Wiring and Software Setup

1. Flash the OS: Use Raspberry Pi Imager to flash 'Raspberry Pi OS Lite (64-bit)' to your A2 microSD card. Configure your WiFi and enable SSH in the imager's advanced settings.
2. Boot and SSH: Insert the SD card, apply 5V power, and SSH into the Pi via your terminal.
3. Enable I2C: Run sudo raspi-config. Navigate to Interface Options > I2C and select Yes to enable the ARM I2C interface. Reboot the Pi.
4. Install Dependencies: Install the Python I2C tools and the BME280 library: sudo apt update && sudo apt install python3-smbus i2c-tools -y
pip3 install RPi.bme280
5. Verify Hardware: Run i2cdetect -y 1. You should see 77 in the grid output, confirming the Pi sees the sensor at hex address 0x77.

The Code: Python I2C Polling with Error Handling

Embedded Linux environments are prone to transient I2C bus lockups, especially if cables are long or poorly shielded. Never write I2C polling code without a try/except block. The following script targets Python 3.9+ on Raspberry Pi OS.

import time
import smbus2
import bme280

# Pin definitions and I2C setup
I2C_BUS = 1
BME280_ADDRESS = 0x77  # Change to 0x76 if using a generic clone board

bus = smbus2.SMBus(I2C_BUS)
calibration_params = bme280.load_calibration_params(bus, BME280_ADDRESS)

def read_environmental_data():
    try:
        data = bme280.sample(bus, BME280_ADDRESS, calibration_params)
        temp_c = round(data.temperature, 2)
        humidity = round(data.humidity, 2)
        pressure = round(data.pressure, 2)
        
        print(f'Temp: {temp_c}C | Humidity: {humidity}% | Pressure: {pressure} hPa')
        return True
        
    except OSError as e:
        # Catching specific I2C hardware failures
        print(f'Hardware I/O Error: {e}')
        return False
    except Exception as e:
        print(f'Unexpected software error: {e}')
        return False

if __name__ == '__main__':
    print('Starting BME280 Polling Loop...')
    while True:
        success = read_environmental_data()
        if not success:
            print('Sensor read failed. Waiting 5 seconds before retry...')
        time.sleep(5)

Debugging: When the I2C Bus Fails

When working with physical GPIO headers, you will inevitably encounter bus communication failures. The most notorious error string you will see in your terminal is:

OSError: [Errno 121] Remote I/O error
or
OSError: [Errno 110] Connection timed out

This means the Linux kernel attempted to clock data out on the SDA/SCL lines, but the sensor did not acknowledge (ACK) the transaction. Here are the first three things to check when this happens, ranked by probability:

1. Swapped SDA and SCL Lines: This accounts for 70% of bench failures. I2C is not plug-and-play reversible. Run i2cdetect -y 1. If the output grid is entirely empty (only dashes), your SDA and SCL wires are almost certainly swapped at the breakout board. Swap them and reboot.
2. Incorrect I2C Address (0x76 vs 0x77): The official Bosch BME280 and Adafruit breakouts default to 0x77. However, cheap, unbranded clone boards from online marketplaces often tie the SDO pin low, changing the address to 0x76. If i2cdetect shows 76, you must update the BME280_ADDRESS variable in the Python script above to match.
3. Pull-Up Resistor Clashes: The I2C spec requires pull-up resistors on SDA and SCL. The Pi has internal 50kΩ pull-ups, and the Adafruit breakout has 10kΩ onboard. If you daisy-chain multiple I2C sensors on the same bus, the parallel resistance drops. If the total pull-up resistance drops below 1kΩ, the Pi's GPIO pins cannot pull the line low fast enough, resulting in corrupted data and Errno 121. Remove the jumper pads on the back of secondary breakouts to disable their onboard resistors.

Scaling the Build: Extend or Simplify

Once your sensor node is logging reliably to the console, you need to decide how this fits into your broader embedded architecture.

How to Extend (The Linux Edge Gateway Route)

If you need this data to trigger home automation routines, extend the Python script using the paho-mqtt library. By adding three lines of code, you can publish the JSON payload to a local Mosquitto broker running on your main Home Assistant server. The Pi Zero 2 W is perfect for this because its WiFi stack handles MQTT keep-alive pings effortlessly in the background while the main thread polls the I2C bus.

How to Simplify (The Bare-Metal Route)

If your only goal is to read a sensor every 10 minutes and you don't need a full Linux OS, Docker, or local databases, you are using the wrong tool. Linux introduces boot times, SD card corruption risks, and a 1.5W idle power draw. To simplify, drop down to a Raspberry Pi Pico W (around $6). You can port the exact same BME280 logic to MicroPython in about 20 lines of code, utilize the Pico's deep sleep modes to drop power consumption to microamps, and transmit the data via WiFi directly to an MQTT broker. Use the Pi Zero 2 W when you need Linux; use the Pico W when you just need the data.