Interfacing with Raspberry Pi 5: I2C Sensors and 3.3V GPIO Relays

Project Scope and Target Board Variant

Interfacing with Raspberry Pi hardware has evolved significantly with the release of the Pi 5. Unlike the Pi 4, which routed GPIO directly through the Broadcom BCM2711 SoC, the Pi 5 utilizes a dedicated RP1 southbridge chip to handle I/O. This architectural shift means stricter 3.3V logic levels, different internal pull-up resistor behaviors, and zero tolerance for 5V back-feeding. If you attempt to interface standard 5V Arduino relay modules directly to a Pi 5 GPIO pin, you risk bricking the RP1 chip or experiencing silent trigger failures due to optocoupler forward-voltage mismatches.

This guide details a robust, bench-tested method for interfacing with Raspberry Pi 5 (4GB or 8GB variants) running Raspberry Pi OS (Bookworm or later). We will wire an Adafruit BME280 environmental sensor via the I2C bus and control a 3.3V-compatible relay module using the gpiozero library. The code provided targets the Pi 5's specific hardware layout and includes comprehensive error handling to prevent GPIO lockups during I2C bus faults.

Hardware BOM and Pin Mapping Matrix

Before cutting wires, verify your components against this bill of materials. Sourcing the correct 3.3V relay module is the most common failure point in Pi 5 builds.

Pin Mapping Table

The following table maps the physical header pins to the Broadcom (BCM) GPIO numbers used in our Python script. Always count pins with the USB ports facing you and the GPIO header on the top right.

Step-by-Step Wiring Procedure

Follow these steps to physically interface the components. Ensure the Pi 5 is completely powered down and unplugged before making GPIO connections.

1. Enable I2C in Firmware: Boot the Pi, open a terminal, and run sudo raspi-config. Navigate to Interface Options > I2C and enable it. Reboot the Pi. Alternatively, ensure dtparam=i2c_arm=on is present in /boot/firmware/config.txt.
2. Wire the Power Rails: Connect Physical Pin 1 (3.3V) to the BME280 VIN and the Relay module VCC. Connect Physical Pin 6 (GND) to the BME280 GND and Relay GND. Do not use the 5V pin (Pin 2) for the BME280 if you are sharing a ground plane with sensitive analog reads, though the Adafruit breakout has an onboard regulator.
3. Connect I2C Data Lines: Route Physical Pin 3 (SDA) to the BME280 SDI pin, and Physical Pin 5 (SCL) to the BME280 SCK pin.
4. Add External Pull-ups (If Needed): The Pi 5 RP1 chip has internal pull-ups, but for wire runs over 10cm, parasitic capacitance will degrade the I2C square wave. Solder 4.7kΩ resistors between the SDA/SCL lines and the 3.3V rail on your breadboard.
5. Wire the Relay Trigger: Connect Physical Pin 11 (GPIO 17) to the Relay module IN1 pin. Verify your relay module is active-LOW or active-HIGH compatible with 3.3V logic. Most 3.3V relay boards use an NPN transistor or logic-level MOSFET that triggers reliably at 3.3V.

Python Control Script with Error Handling

This script uses the Adafruit Blinka ecosystem for the I2C sensor and the native GPIO Zero library for the relay. Install the dependencies first: pip3 install adafruit-circuitpython-bme280 gpiozero.

import time
import sys
import board
import busio
import adafruit_bme280
from gpiozero import OutputDevice
from gpiozero.exc import PinPWMUnsupported, GPIOPinInUse

# --- PIN & CONFIGURATION DEFINITIONS ---
RELAY_GPIO_BCM = 17
I2C_SDA_PIN = board.SDA
I2C_SCL_PIN = board.SCL
SENSOR_I2C_ADDRESS = 0x77  # Default for Adafruit BME280 (0x76 for generic clones)
READ_INTERVAL_SEC = 5.0
RELAY_ON_THRESHOLD_TEMP = 25.0  # Celsius

# --- HARDWARE INITIALIZATION ---
def init_hardware():
    """Initialize I2C bus and GPIO relay with explicit error handling."""
    try:
        i2c = busio.I2C(I2C_SCL_PIN, I2C_SDA_PIN, frequency=100000)
        sensor = adafruit_bme280.Adafruit_BME280_I2C(i2c, address=SENSOR_I2C_ADDRESS)
        sensor.sea_level_pressure = 1013.25
    except ValueError as e:
        print(f"[FATAL] I2C Sensor not found at 0x{SENSOR_I2C_ADDRESS:02X}. Check wiring and address.")
        sys.exit(1)
    except RuntimeError as e:
        print(f"[FATAL] I2C Bus error: {e}. Is I2C enabled in raspi-config?")
        sys.exit(1)

    try:
        relay = OutputDevice(RELAY_GPIO_BCM, active_high=True, initial_value=False)
    except GPIOPinInUse:
        print(f"[FATAL] GPIO {RELAY_GPIO_BCM} is already in use by another process.")
        sys.exit(1)

    return sensor, relay

def main():
    sensor, relay = init_hardware()
    print("System initialized. Monitoring environment...")

    try:
        while True:
            temp_c = sensor.temperature
            humidity = sensor.humidity
            pressure = sensor.pressure

            print(f"Temp: {temp_c:.1f}°C | Humidity: {humidity:.1f}% | Pressure: {pressure:.1f} hPa")

            # Hysteresis logic to prevent relay chatter at threshold boundary
            if temp_c > RELAY_ON_THRESHOLD_TEMP + 0.5:
                if not relay.is_active:
                    relay.on()
                    print("[ACTION] Relay ENGAGED (Cooling/Fan ON)")
            elif temp_c < RELAY_ON_THRESHOLD_TEMP - 0.5:
                if relay.is_active:
                    relay.off()
                    print("[ACTION] Relay DISENGAGED (Cooling/Fan OFF)")

            time.sleep(READ_INTERVAL_SEC)

    except KeyboardInterrupt:
        print("\n[INFO] Interrupt received. Safely shutting down...")
    except OSError as e:
        print(f"\n[ERROR] I2C Bus dropped during runtime: {e}")
    finally:
        relay.off()
        relay.close()
        print("GPIO cleaned up. Exiting.")

if __name__ == "__main__":
    main()

Debugging: Fixing I2C and GPIO Faults

When interfacing with Raspberry Pi hardware, I2C bus failures are the most common roadblock. If your script crashes immediately upon sensor initialization, you will likely see this exact traceback:

OSError: [Errno 121] Remote I/O error

This error occurs when the Linux I2C driver sends a request to the bus, but the target device fails to acknowledge (NACK) the transaction. Here are the ranked causes and how to fix them:

1. Wrong I2C Address (Most Likely): Generic BME280 clone boards often default to 0x76, while the official Adafruit breakout defaults to 0x77. Open your terminal and run i2cdetect -y 1. If you see 76 in the grid, change SENSOR_I2C_ADDRESS = 0x77 to 0x76 in the Python script.
2. I2C Interface Disabled: If i2cdetect returns an empty grid or throws a "No such file or directory" error, the kernel module isn't loaded. Run sudo raspi-config, enable I2C, and reboot. Verify dtparam=i2c_arm=on is in config.txt.
3. Missing Pull-Up Resistors / Wire Capacitance: The Pi 5 RP1 chip's internal pull-ups are relatively weak (~50kΩ). If your jumper wires are longer than 15cm, the SDA line won't rise fast enough to register a logic HIGH, resulting in a NACK. Add external 4.7kΩ pull-up resistors to the 3.3V rail.
4. SDA/SCL Swapped: It sounds basic, but swapping SDA and SCL will silently fail to initialize and throw Errno 121. Verify Physical Pin 3 is SDA and Pin 5 is SCL.

Scaling the Build: Extensions and Simplifications

Once you have verified stable communication and relay switching, you can adapt this architecture to fit different project constraints.

How to Simplify the Build

If you only need to log data and don't require physical relay switching, drop the gpiozero dependency entirely. Replace the relay logic with a simple CSV file writer or an MQTT publish command using the paho-mqtt library. This reduces the hardware BOM to just the Pi and the sensor, eliminating the risk of inductive kickback from relay coils interfering with the I2C bus.

How to Extend the Build

To scale this into a multi-zone climate controller, you cannot simply wire more BME280 sensors to the same I2C bus—they share the same default addresses. Instead, use a TCA9548A I2C Multiplexer. This chip sits on the primary I2C bus and allows you to route up to 8 separate I2C channels, letting you interface up to eight BME280 sensors without address conflicts. For the output side, replace the 4-channel mechanical relay with an 8-channel Solid State Relay (SSR) board. SSRs eliminate the mechanical contact bounce and acoustic noise, and they draw significantly less trigger current from the Pi 5's GPIO pins, preserving the lifespan of the RP1 southbridge.