Practical Projects on Raspberry Pi 3: Build a Robust I2C Environmental Monitor

When evaluating projects on Raspberry Pi 3 hardware for bench or light industrial use, the I2C bus is the most common point of failure. The Raspberry Pi 3 Model B+ remains a workhorse for embedded sensor nodes due to its predictable GPIO layout and low power draw, but its internal 1.8kΩ pull-up resistors and strict 5V/2.5A power envelope demand precise wiring. This guide walks through building a robust environmental monitor using a BME280 sensor and an SSD1306 OLED display, terminating in production-grade Python code that explicitly catches and handles I2C bus faults.

Decision Path: Selecting the Right Pi 3 Variant

Before buying parts, you must lock in the exact board variant. The Pi 3 family has three main revisions, and picking the wrong one for a sensor project will cause thermal throttling or power brownouts.

Parts List and Hardware Specifications

Do not substitute the BME280 with a BMP280; the BMP280 lacks the humidity sensor and uses different calibration registers, which will crash the code below. Prices reflect typical 2026 market rates for genuine components.

Pin Mapping and Wiring Procedure

The Raspberry Pi 3 B+ uses the standard 40-pin header. We are utilizing I2C Bus 1, which is the default hardware I2C bus mapped to GPIO 2 (SDA) and GPIO 3 (SCL). Both devices will share this bus.

Wiring Steps:

1. Disconnect the Pi from power. Never hot-plug I2C sensors; the SDA/SCL lines can spike and damage the BCM2837 I2C controller.
2. Route the 3.3V and Ground rails from the Pi to the breadboard power rails using 24 AWG wire.
3. Connect the SDA (Pin 3) and SCL (Pin 5) lines to the shared breadboard I2C bus lines.
4. Wire the BME280 and SSD1306 to the shared power and I2C rails.
5. Critical Check: Verify the BME280 address jumper. Adafruit boards default to 0x77. If using a generic clone, it may default to 0x76. Check the silkscreen on the back of the board.

Complete Python Code with I2C Error Handling

This code targets the Raspberry Pi 3 Model B+ running Raspberry Pi OS (Bookworm or newer). It uses the Adafruit CircuitPython libraries, which are the standard for Pi sensor integration.

Prerequisite: Install dependencies via terminal:
sudo pip3 install adafruit-circuitpython-bme280 adafruit-circuitpython-ssd1306 pillow

import time
import sys
import board
import busio
import digitalio
from PIL import Image, ImageDraw, ImageFont
import adafruit_ssd1306
import adafruit_bme280

# --- PIN & ADDRESS DEFINITIONS (Pi 3 Model B+) ---
I2C_SDA_PIN = board.SDA   # Physical Pin 3
I2C_SCL_PIN = board.SCL   # Physical Pin 5
BME280_I2C_ADDR = 0x77    # Adafruit default; change to 0x76 for generic clones
OLED_I2C_ADDR = 0x3C      # Standard for 128x64 I2C OLEDs
OLED_RESET_PIN = digitalio.DigitalInOut(board.D4) # Physical Pin 7

def initialize_hardware():
    """Initializes I2C bus and sensors with explicit fault catching."""
    try:
        i2c = busio.I2C(I2C_SCL_PIN, I2C_SDA_PIN)
        
        # Initialize BME280
        bme_sensor = adafruit_bme280.Adafruit_BME280_I2C(i2c, address=BME280_I2C_ADDR)
        bme_sensor.sea_level_pressure = 1013.25
        
        # Initialize SSD1306 OLED
        oled_display = adafruit_ssd1306.SSD1306_I2C(
            128, 64, i2c, addr=OLED_I2C_ADDR, reset=OLED_RESET_PIN
        )
        oled_display.fill(0)
        oled_display.show()
        
        return bme_sensor, oled_display
        
    except ValueError as e:
        print(f"FATAL: Hardware not found on I2C bus. {e}")
        print("Action: Run 'sudo i2cdetect -y 1' to verify addresses.")
        sys.exit(1)

def main_loop(sensor, display):
    """Polls sensor and updates display, handling runtime I2C drops."""
    font = ImageFont.load_default()
    
    while True:
        try:
            # Read sensor data
            temp_c = sensor.temperature
            humidity = sensor.humidity
            pressure = sensor.pressure
            
            # Create image buffer for OLED
            image = Image.new('1', (display.width, display.height))
            draw = ImageDraw.Draw(image)
            
            draw.text((0, 0), f"Temp: {temp_c:.1f} C", font=font, fill=255)
            draw.text((0, 16), f"Hum:  {humidity:.1f} %", font=font, fill=255)
            draw.text((0, 32), f"Pres: {pressure:.1f} hPa", font=font, fill=255)
            
            display.image(image)
            display.show()
            
            # Sleep for 2 seconds to prevent I2C bus flooding
            time.sleep(2.0)
            
        except OSError as e:
            # Catch the exact I2C runtime error
            if "[Errno 121]" in str(e):
                print("WARNING: I2C Bus dropped: OSError: [Errno 121] Remote I/O error.")
                print("Action: Check physical wiring and pull-up resistors. Retrying in 5s...")
                time.sleep(5)
            else:
                print(f"Unexpected OS Error: {e}")
                sys.exit(1)
        except KeyboardInterrupt:
            print("\nShutting down gracefully.")
            display.fill(0)
            display.show()
            sys.exit(0)

if __name__ == "__main__":
    bme, oled = initialize_hardware()
    main_loop(bme, oled)

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

If you are building projects on Raspberry Pi 3 hardware, you will eventually encounter the dreaded I2C bus drop. The Python interpreter will throw this exact string:

OSError: [Errno 121] Remote I/O error

This is not a software bug; it is a physical layer failure. The BCM2837 SoC attempted to clock data out on the SCL line, but the SDA line did not acknowledge (ACK) the transaction within the hardware timeout window.

The First Three Things to Check

1. Run sudo i2cdetect -y 1: If the output shows -- instead of 77 and 3c, the Pi cannot see the devices at all. If it shows UU, the kernel driver has already claimed the device (conflict).
2. Measure the 3.3V Rail: Use a multimeter to check the voltage between Pin 1 (3.3V) and Pin 6 (GND). If it reads below 3.2V, your power supply is sagging under load, causing the BME280 to brownout and drop off the bus.
3. Check Wire Length and Capacitance: The I2C specification limits bus capacitance to 400pF. Standard jumper wires add roughly 2pF per inch. If your wires exceed 12 inches, the signal edges degrade, causing missed ACKs.

Ranked Causes and Fixes

Extending and Simplifying the Build

Once the baseline monitor is stable, you must decide how to adapt it for your specific deployment environment.

By strictly defining your hardware variant, addressing the physical limitations of the Pi 3's I2C bus, and implementing explicit error handling for bus drops, you transform a fragile breadboard prototype into a reliable environmental monitoring node. Stick to the Pi 3 Model B+, keep your I2C wire runs under 12 inches, and always catch [Errno 121] in your production loops.