Good Uses for Raspberry Pi: Building an I2C Environmental Data Logger

When makers ask about the most reliable, high-impact good uses for Raspberry Pi, the conversation often drifts toward retro gaming or media centers. But from an engineering perspective, one of the most robust applications for a Pi is deploying it as a headless edge-computing node for environmental data logging. Unlike bare-metal microcontrollers (like an ESP32 or Arduino), a Raspberry Pi running Linux gives you native cron scheduling, local SQLite/CSV storage, a full TCP/IP stack for MQTT publishing, and the horsepower to run local data aggregation scripts without breaking a sweat.

This guide walks through building a precision I2C environmental logger using a Raspberry Pi 5 and a Bosch BME280 sensor. We will cover hardware selection, exact pin mappings, a production-ready Python script with error handling, and the specific I2C bus failures you will inevitably encounter on the bench.

Hardware Selection: Which Pi Model Fits the Job?

Not every logging job requires the latest silicon. If you are polling a sensor every 60 seconds and writing to a local file, you are bottlenecked by I/O and bus speeds, not CPU cycles. Here is a data-dense comparison of the current Raspberry Pi lineup for edge-logging tasks in 2026.

The Verdict: For this build, we are targeting the Raspberry Pi 5 (4GB). While it is overkill for simple 1-minute polling, the Pi 5's PCIe interface and improved power management make it the standard workbench baseline for 2026. If your deployment is strictly headless and space-constrained, downgrade to the Pi Zero 2 W; the Python code provided below is 100% compatible across all four boards.

Parts List and Pin Mapping

The Bosch BME280 is the gold standard for hobbyist and prosumer environmental sensing. It measures temperature, humidity, and barometric pressure with excellent long-term stability. Avoid the cheaper BMP280 (no humidity) or the DHT11/22 (poor accuracy and slow polling).

Bill of Materials

• Compute: Raspberry Pi 5 (4GB RAM)
• Sensor: Adafruit BME280 I2C/SPI Breakout (Product ID: 2652). Includes onboard 3.3V regulator and I2C pull-ups.
• Thermal: Pi 5 Active Cooler (mandatory for enclosed headless logging to prevent thermal throttling).
• Storage: 32GB SanDisk High Endurance microSD (crucial for continuous write-cycle logging).
• Wiring: 26 AWG silicone jumper wires (female-to-female).

Pin Mapping Table

The Raspberry Pi's hardware I2C bus (Bus 1) operates at 3.3V logic. Because the Adafruit BME280 breakout is also 3.3V native, we can wire it directly without a logic level converter.

Assembly and I2C Bus Configuration

Before writing code, the Linux kernel must be instructed to load the I2C device tree overlays.

1. Wire the breakout to the Pi according to the pin mapping table above.
2. Boot the Pi and open a terminal (or SSH in).
3. Run the configuration tool: sudo raspi-config
4. Navigate to Interface Options > I2C and select Yes to enable it.
5. Reboot the Pi: sudo reboot
6. Install the I2C tools and Python dependencies:

   sudo apt update
   sudo apt install i2c-tools python3-pip
   pip3 install adafruit-blinka adafruit-circuitpython-bme280

7. Verify the hardware connection by scanning the bus:

   i2cdetect -y 1

   You should see 76 in the output grid. If the grid is empty, check your wiring before proceeding.

The Python Logging Script

This script targets the Raspberry Pi 5 (and 4/Zero 2 W) using the Adafruit Blinka compatibility layer. It reads the sensor, calculates altitude based on sea-level pressure, and appends the data to a CSV file. It includes robust error handling to prevent the script from crashing if the I2C bus momentarily locks up—a common occurrence in electrically noisy environments.

import time
import board
import busio
import adafruit_bme280
import csv
import os
from datetime import datetime

# --- PIN DEFINITIONS & CONFIGURATION ---
I2C_SDA = board.SDA
I2C_SCL = board.SCL
SENSOR_ADDR = 0x76  # Default for Adafruit BME280
LOG_FILE = '/home/pi/env_data.csv'
POLL_INTERVAL_SEC = 60

def init_sensor():
    """Initialize the I2C bus and BME280 sensor."""
    i2c = busio.I2C(I2C_SCL, I2C_SDA)
    try:
        sensor = adafruit_bme280.Adafruit_BME280_I2C(i2c, address=SENSOR_ADDR)
        sensor.sea_level_pressure = 1013.25  # Adjust for your local altitude
        return sensor
    except ValueError as e:
        print(f'[FATAL] Hardware fault during init: {e}')
        raise

def log_data(sensor):
    """Read sensor and append to CSV."""
    timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
    temp_c = sensor.temperature
    humidity = sensor.relative_humidity
    pressure_hpa = sensor.pressure
    altitude_m = sensor.altitude

    # Check if file exists to write headers
    file_exists = os.path.isfile(LOG_FILE)
    
    try:
        with open(LOG_FILE, 'a', newline='') as f:
            writer = csv.writer(f)
            if not file_exists:
                writer.writerow(['Timestamp', 'Temp_C', 'Humidity_%', 'Pressure_hPa', 'Altitude_m'])
            writer.writerow([timestamp, f'{temp_c:.2f}', f'{humidity:.2f}', f'{pressure_hpa:.2f}', f'{altitude_m:.2f}'])
        print(f'[{timestamp}] Logged: {temp_c:.2f}C | {humidity:.2f}% | {pressure_hpa:.2f}hPa')
    except IOError as e:
        print(f'[ERROR] File write failed: {e}')

if __name__ == '__main__':
    sensor = init_sensor()
    print('Starting environmental logger... Press Ctrl+C to stop.')
    try:
        while True:
            try:
                log_data(sensor)
            except OSError as e:
                # Catches transient I2C bus lockups
                print(f'[WARNING] I2C Bus Error: {e}. Retrying next cycle.')
            time.sleep(POLL_INTERVAL_SEC)
    except KeyboardInterrupt:
        print('\nLogger stopped by user.')

Note: To run this continuously in the background, set it up as a systemd service rather than relying on a raw cron job, which ensures it restarts automatically if the script crashes.

Debugging: When the I2C Bus Fails

I2C is notoriously fragile over long wire runs. When your script crashes, it will almost always throw one of two specific exceptions. Here is how to decode them.

Error 1: The Missing Device Node

Exact Error String: FileNotFoundError: [Errno 2] No such file or directory '/dev/i2c-1'

Ranked Causes:

1. You forgot to enable the I2C interface in raspi-config.
2. You are running an outdated or custom kernel that lacks the i2c-bcm2835 module.
3. You are trying to access the bus before the udev rules have finished loading at boot (common in aggressive systemd service configurations).

Error 2: The Bus Lockup or Disconnect

Exact Error String: ValueError: No I2C device at address: 0x76 OR OSError: [Errno 121] Remote I/O error

Ranked Causes:

1. Address Mismatch: The sensor is configured for 0x77 but the code requests 0x76.
2. Missing Pull-ups: If using a raw BME280 chip or a cheap clone board without onboard resistors, the SDA/SCL lines are floating. The Pi's internal pull-ups (typically 50kΩ) are too weak for reliable I2C; you need external 4.7kΩ pull-ups to 3.3V.
3. Capacitance / Wire Length: I2C is not designed for long runs. If your jumper wires exceed 30cm (12 inches), bus capacitance degrades the square wave into a sawtooth, causing the Pi to miss ACK bits.

Extending or Simplifying the Build

One of the best aspects of using a Pi for edge logging is the scalability. You can easily adapt this exact hardware and codebase to fit different deployment constraints.

How to Simplify (The Low-Power Route)

If this node is going into a weatherproof enclosure in the backyard, the Pi 5 is overkill and draws too much idle current. Swap the Pi 5 for a Raspberry Pi Zero 2 W. The GPIO pinout is identical, and the Python code requires zero modifications. To further protect the hardware, wrap the BME280 in a PTFE (Teflon) membrane vent to allow air exchange while blocking liquid water, and power the Zero 2 W via a 5V solar bank with a dedicated LiPo charge controller.

How to Extend (The Smart Home Route)

Local CSV files are fine for offline analysis, but real-time dashboards are better. To integrate this logger into a smart home ecosystem, extend the Python script using the paho-mqtt library. Instead of writing to a CSV, format the sensor readings as a JSON payload and publish it to an MQTT broker (like Mosquitto running on your Home Assistant server). This allows you to trigger automations—like turning on a dehumidifier when the BME280 reports >65% relative humidity—without polling a local file.

Finally, consider microSD wear-leveling. Continuous CSV appending will eventually kill a standard consumer SD card. If you extend the build to log every 5 seconds, switch from CSV to a local SQLite database with Write-Ahead Logging (WAL) enabled, or mount a USB SSD via the Pi 5's USB 3.0 ports to offload the write cycles entirely.