Coding with Raspberry Pi 5: I2C Sensor Relays and Debugging Errno 121

Coding with Raspberry Pi for embedded hardware means bridging the gap between high-level Python and the Linux kernel's I2C, SPI, and GPIO character devices. Unlike bare-metal microcontrollers, the Pi runs a full OS, which introduces latency and permission layers that catch many makers off guard. This guide cuts through the abstraction, providing a decision framework for board selection, a complete I2C sensor-to-relay build, and a definitive debugging path for the most common I2C failure mode.

Decision Tree: Which Raspberry Pi Board for Embedded Coding?

Before writing a single line of code, you must select the right silicon. The Raspberry Pi ecosystem has fragmented into distinct use cases. Use this decision matrix to pick your board.

Project Build: I2C Environmental Relay Controller

We are building a thermostat-style controller: a BME280 reads temperature and humidity over I2C, and if the temperature exceeds a threshold, the Pi triggers a relay to switch on an exhaust fan. This build highlights the critical difference between 5V and 3.3V logic in embedded coding.

Parts List

• Compute: Raspberry Pi 5 (4GB) with Active Cooler
• Sensor: Adafruit BME280 I2C Breakout (Product ID: 2652) — Do not use unbranded clones without onboard pull-ups.
• Actuator: 3.3V Optocoupler Relay Module (SRD-05VDC-SL-C with 3.3V trigger) — Crucial: Standard 5V relay modules backfeed 5V into the Pi's 3.3V GPIO, which will fry the Pi 5's RP1 chip.
• Wiring: 22 AWG silicone jumper wires, female-to-female and male-to-female.

Wiring and Pin Mapping

The Raspberry Pi 5 uses the standard 40-pin header, but the underlying GPIO controller (the RP1 chip) handles I2C slightly differently than the BCM2711 on the Pi 4. Physical pin numbers remain identical.

Complete Python Code with Error Handling

This script uses adafruit-circuitpython-bme280 for the sensor and gpiozero for the relay. It includes robust try/except blocks to catch I2C bus drops and ensure the relay fails safe (turns off) if the script crashes.

Prerequisites: Run sudo apt install python3-pip python3-venv, create a venv, and pip install adafruit-circuitpython-bme280 gpiozero.

import time
import board
import busio
import adafruit_bme280
from gpiozero import OutputDevice
from signal import pause
import sys

# --- PIN DEFINITIONS ---
# Relay is connected to Physical Pin 40, which is BCM GPIO 21
RELAY_PIN = 21 
TEMP_THRESHOLD = 28.5  # Celsius

# Initialize Relay (Active LOW for most optocoupler modules)
# If your relay clicks ON when the script starts, change active_high=True
relay = OutputDevice(RELAY_PIN, active_high=False, initial_value=False)

def setup_i2c_sensor():
    """Initialize the I2C bus and BME280 sensor with error handling."""
    try:
        # Pi 5 uses the standard I2C1 bus on SDA=GPIO2, SCL=GPIO3
        i2c = busio.I2C(board.SCL, board.SDA)
        # BME280 default I2C address is 0x77. Some clones use 0x76.
        sensor = adafruit_bme280.Adafruit_BME280_I2C(i2c, address=0x77)
        sensor.sea_level_pressure = 1013.25
        return sensor
    except ValueError as e:
        print(f"[FATAL] I2C Address Error: {e}")
        print("Check if your sensor uses 0x76 instead of 0x77.")
        sys.exit(1)
    except Exception as e:
        print(f"[FATAL] Could not initialize I2C bus: {e}")
        print("Ensure I2C is enabled in raspi-config and wiring is correct.")
        sys.exit(1)

def main_loop(sensor):
    print("Starting environmental monitor. Press Ctrl+C to stop.")
    try:
        while True:
            temp_c = sensor.temperature
            humidity = sensor.humidity
            
            print(f"Temp: {temp_c:.2f} C | Humidity: {humidity:.1f}%")
            
            # Decision logic for relay
            if temp_c >= TEMP_THRESHOLD:
                if not relay.value:
                    print("[ACTION] Threshold exceeded. Triggering exhaust fan.")
                    relay.on()
            else:
                if relay.value:
                    print("[ACTION] Temp normal. Disengaging exhaust fan.")
                    relay.off()
                    
            time.sleep(2.0) # 2-second polling interval
            
    except KeyboardInterrupt:
        print("\n[INFO] Interrupt received. Cleaning up...")
    except OSError as e:
        print(f"\n[CRITICAL] I2C Bus Dropped: {e}")
    finally:
        # Fail-safe: Ensure relay is OFF when script exits
        relay.off()
        relay.close()
        print("[SAFE] Relay disengaged. GPIO cleaned up.")

if __name__ == '__main__':
    bme_sensor = setup_i2c_sensor()
    main_loop(bme_sensor)

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

When coding with Raspberry Pi over I2C, you will inevitably hit this wall. The Linux kernel throws this error when the I2C controller sends a clock pulse but receives no ACK (acknowledge) bit from the target device.

The Exact Error String:
OSError: [Errno 121] Remote I/O error

Ranked Causes (Most Likely First)

1. I2C Interface Disabled in OS: The kernel overlay for the ARM I2C bus is missing or commented out in the boot configuration.
2. Missing Pull-Up Resistors: The I2C spec requires pull-up resistors (usually 4.7kΩ) on SDA and SCL. Cheap, unbranded sensor breakouts often omit these, causing the signal lines to float and the Pi's RP1 chip to read garbage.
3. Wrong I2C Address: The code is polling 0x77, but the physical breakout board has the SDO pin tied low, shifting the address to 0x76.
4. Bus Capacitance / Wire Length: I2C is not designed for long runs. If your jumper wires exceed 30cm (12 inches), the capacitance degrades the square wave into a triangle wave, causing ACK timeouts.

The First Three Things to Check When It Fails

Do not rewrite your Python code. The hardware or OS configuration is failing. Run these checks in order:

1. Run the I2C Detect Tool:
   Open the terminal and run sudo i2cdetect -y 1.
   Expected output: A grid showing 77 (or 76).
   If you see a grid of all dashes (--): The Pi cannot see the device. Check physical wiring and pull-ups.
   If you see UU: The kernel has already claimed the device (rare on Pi 5, common if using RTC overlays).
2. Verify the Config Overlay:
   Check your boot config. On modern Raspberry Pi OS (Bookworm+), open the terminal and run:
   sudo nano /boot/firmware/config.txt
   Ensure the line dtparam=i2c_arm=on is present and not commented out with a #. Reboot if you change it.
3. Measure Physical Continuity:
   Power down the Pi. Set your multimeter to continuity (beep mode). Probe the Pi's Pin 3 (SDA) to the BME280's SDA pad. Probe Pin 5 (SCL) to the SCL pad. A lack of a beep means a broken jumper wire or a cold solder joint on the breakout header.

Extending and Simplifying the Build

Once the baseline I2C polling and relay switching is stable, you will likely need to adapt the project to your specific environment. Here is how to scale the architecture up or down.

How to Extend (Adding Network Telemetry)

To turn this into an IoT node, integrate the paho-mqtt library. Instead of just printing to the console, publish the sensor dictionary to a local Mosquitto broker. Add this inside the while True loop:

import paho.mqtt.client as mqtt
import json

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

# Inside loop:
payload = json.dumps({'temp': temp_c, 'hum': humidity, 'relay': relay.value})
client.publish('home/server_rack/climate', payload)

Note: Keep the polling interval at 2 seconds or higher. The BME280's internal heater can skew temperature readings if polled continuously at sub-second intervals.

How to Simplify (Bypassing I2C Entirely)

If I2C debugging is blocking your progress and you just need basic temperature/humidity data, swap the BME280 for a DHT22 (AM2302). The DHT22 uses a single-wire proprietary protocol on a standard digital GPIO pin. It requires no I2C bus configuration, no pull-up resistors on the Pi side (it has one built-in), and eliminates the Errno 121 error class entirely. The trade-off is speed: the DHT22 can only be polled once every 2 seconds, and its humidity accuracy drifts by ±2% compared to the BME280's ±1%. For a simple exhaust fan trigger, this is an acceptable trade.

For deeper reading on Pi I2C bus configuration and sensor integration, consult the official Raspberry Pi I2C documentation and the Adafruit BME280 CircuitPython guide.