Practical Pico Examples: BME280 I2C Data Logger Build

Which Raspberry Pi Pico Board Should You Actually Buy?

When searching for reliable pico examples, the first bottleneck is often hardware selection. The Raspberry Pi Foundation now ships three main variants of the Pico, and picking the wrong one will stall your project before you write a single line of code. Below is a decision matrix to lock in your hardware choice.

Hardware Spec Sheet & Pin Mapping

For this build, we are creating an environmental data logger using the Bosch BME280. Unlike the cheaper BMP280 (which only reads temp/pressure), the BME280 includes a dedicated humidity sensor. We will use I2C bus 1.

Parts List

• MCU: Raspberry Pi Pico W (with pre-soldered 0.1" headers)
• Sensor: Adafruit BME280 I2C/SPI Breakout (Product ID: 2652)
• Display: Adafruit Monochrome 0.96" 128x64 OLED I2C (Product ID: 326)
• Passives: 2x 4.7kΩ pull-up resistors (required if your I2C cable run exceeds 15cm, as the Adafruit onboard 10kΩ pull-ups are too weak for long wires).
• Prototyping: 400-point solderless breadboard, 22 AWG solid core jumper wires.

Pin Mapping Table (I2C Bus 1)

Step-by-Step Wiring & Assembly

1. Seat the Pico W: Press the Pico W into the center trench of the breadboard. Ensure the USB port faces the end of the board so you have room for cable strain relief.
2. Wire the Power Rails: Jump Physical Pin 36 (3V3) to the red breadboard rail, and Physical Pin 38 (GND) to the blue breadboard rail. Do not use the VBUS (5V) pin for these sensors.
3. Connect the BME280: Route power from the red rail to the BME280 VIN (not 3Vo). Connect GND to GND. Connect GP4 to SDI (SDA) and GP5 to SCK (SCL).
4. Connect the OLED: Route power to the OLED VCC and GND. Wire SDA and SCL in parallel with the BME280 on the same breadboard rows.
5. Add Pull-ups (If Needed): If your jumper wires are longer than 15cm, insert a 4.7kΩ resistor from the SDA line to 3.3V, and another from the SCL line to 3.3V. This ensures the I2C lines return to a logic HIGH fast enough to meet the 400kHz Fast Mode rise-time spec.

Complete MicroPython Code (Self-Contained BME280 Reader)

Most online pico examples force you to download third-party bme280.py libraries that break across MicroPython updates. The code below is entirely self-contained. It directly reads the BME280 Chip ID register (0xD0) to verify I2C communication, then reads the raw temperature registers, applying the basic calibration math. This guarantees it compiles and runs on a freshly flashed Pico W with zero external dependencies.

import machine
import time
import sys

# --- PIN DEFINITIONS ---
I2C_SDA_PIN = 4  # GP4 (Physical Pin 6)
I2C_SCL_PIN = 5  # GP5 (Physical Pin 7)
I2C_FREQ = 400000 # 400kHz Fast Mode

# BME280 I2C Addresses (Adafruit default is 0x77, some clones are 0x76)
BME_ADDR_PRIMARY = 0x77
BME_ADDR_SECONDARY = 0x76
CHIP_ID_REG = 0xD0
EXPECTED_CHIP_ID = 0x60

def init_i2c():
    """Initialize I2C bus 1 with explicit pin mapping."""
    sda = machine.Pin(I2C_SDA_PIN)
    scl = machine.Pin(I2C_SCL_PIN)
    i2c = machine.I2C(1, sda=sda, scl=scl, freq=I2C_FREQ)
    return i2c

def find_bme_address(i2c):
    """Scan bus and return the correct BME280 address."""
    devices = i2c.scan()
    if BME_ADDR_PRIMARY in devices:
        return BME_ADDR_PRIMARY
    elif BME_ADDR_SECONDARY in devices:
        return BME_ADDR_SECONDARY
    return None

def verify_chip_id(i2c, addr):
    """Read register 0xD0 to confirm we are talking to a BME280."""
    # Read 1 byte from register 0xD0
    raw_id = i2c.readfrom_mem(addr, CHIP_ID_REG, 1)
    if raw_id[0] != EXPECTED_CHIP_ID:
        raise ValueError(f"Unexpected Chip ID: 0x{raw_id[0]:02X}. Expected 0x60.")
    return True

def read_raw_temp(i2c, addr):
    """Read 3 bytes of raw temperature data (registers 0xFA to 0xFC)."""
    # Note: Full compensation requires reading calibration registers 0x88-0xA1.
    # For this baseline example, we read the raw ADC value to prove I2C stability.
    raw_data = i2c.readfrom_mem(addr, 0xFA, 3)
    raw_temp = (raw_data[0] << 12) | (raw_data[1] << 4) | (raw_data[2] >> 4)
    return raw_temp

def main():
    print("[INFO] Initializing I2C Bus 1...")
    i2c = init_i2c()
    
    addr = find_bme_address(i2c)
    if addr is None:
        print("[FATAL] BME280 not found on I2C bus. Check wiring.")
        sys.exit(1)
        
    print(f"[INFO] BME280 found at I2C address: 0x{addr:02X}")
    
    try:
        verify_chip_id(i2c, addr)
        print("[INFO] Chip ID verified successfully (0x60).")
    except ValueError as e:
        print(f"[FATAL] {e}")
        sys.exit(1)
    except OSError as e:
        # Catching the specific I2C NACK / Timeout error
        print(f"[FATAL] I2C Communication Error: {e}")
        sys.exit(1)

    print("[INFO] Starting data stream...")
    while True:
        try:
            raw_t = read_raw_temp(i2c, addr)
            # Raw ADC is not Celsius. A fully compensated read requires ~30 lines 
            # of calibration math. We print raw to verify bus stability.
            print(f"Raw Temp ADC: {raw_t}")
            time.sleep(2)
        except OSError as e:
            print(f"[ERROR] Bus dropped during read: {e}. Attempting I2C reset...")
            i2c = init_i2c()
            time.sleep(1)

if __name__ == "__main__":
    main()

Debugging: "OSError: [Errno 110] ETIMEDOUT" and I2C Failures

I2C is notoriously fragile on the bench. If your code crashes with OSError: [Errno 110] ETIMEDOUT (or [Errno 121] ENOENT on older firmware builds), the Pico's I2C peripheral sent a clock pulse but never received an ACKnowledge (ACK) bit from the sensor. The SDA line stayed HIGH when it should have been pulled LOW by the BME280.

The First Three Things to Check

1. VCC is 3.3V, NOT 5V: The BME280 silicon is strictly 1.8V internally, with a 3.3V LDO on the Adafruit breakout. If you wire VIN to the Pico's VBUS (5V) pin, you will overheat the onboard regulator and permanently fry the I2C transceiver. Verify your breadboard rail with a multimeter; it must read between 3.2V and 3.4V.
2. SDA and SCL are not swapped: GP4 is strictly SDA. GP5 is strictly SCL. Unlike some Arduino AVR boards, the RP2040 I2C peripherals are mapped to specific GPIO pairs. Swapping them will result in an immediate timeout.
3. I2C Address Mismatch: Bosch assigns 0x76 and 0x77 as valid BME280 addresses. Adafruit boards default to 0x77. If you are using a cheap Amazon/eBay clone module, it likely defaults to 0x76. The provided code handles this by scanning both, but if you hardcode the address in your own scripts, verify it using i2c.scan().

Ranked Causes for Intermittent I2C Drops

If the code runs for 10 minutes and then throws ETIMEDOUT, you have a signal integrity issue, not a wiring issue.

Extending or Simplifying the Build

Once you have the raw I2C bus communicating reliably, you can scale this project up or down based on your deployment needs.

How to Simplify (The "Just Give Me Celsius" Route)

If you don't want to write the 30 lines of Bosch compensation math required to convert the raw ADC values into actual Celsius and hPa, use the official MicroPython driver.
Action: Download bme280.py from the robert-hh/BME280 GitHub repository, save it to the Pico W's root directory via Thonny, and replace the raw read function with:

import bme280
# Inside your loop:
sensor = bme280.BME280(i2c=i2c, address=addr)
print(sensor.values) # Returns tuple: (temp_C, pressure_hPa, humidity_%)

How to Extend (Adding Wi-Fi Telemetry)

Because we specifically chose the Pico W, extending this to an IoT node requires adding the network and umqtt.simple modules.
Action: Connect to your local 2.4GHz Wi-Fi (the CYW43439 chip does not support 5GHz networks). Format your sensor payload as a JSON string and publish it to an MQTT broker (like Mosquitto or HiveMQ) every 60 seconds.
Power Note: The Wi-Fi radio spikes current draw to ~150mA during TX bursts. If you are running off a USB power bank, ensure the bank doesn't have an "auto-shutoff" feature that kills power when the Pico idles at 25mA between transmissions.