5 Interesting Things to Do With Raspberry Pi: Build an E-Ink Air Quality Monitor

Project Overview & Difficulty Rating

When makers search for interesting things to do with Raspberry Pi, they often hit a wall of recycled media center and retro-gaming tutorials. In 2026, the real value of the Pi ecosystem lies in edge-computing environmental monitoring. This project builds a wall-mounted, ultra-low-power Air Quality Index (AQI) dashboard using a Raspberry Pi Zero 2 W, a Bosch BME688 gas sensor, a Plantower PMS5003 particulate sensor, and a Waveshare E-Ink display.

Hardware BOM & Pin Mapping

To execute this build, you need exact hardware variants. Do not substitute the PMS5003 with a cheaper MQ-135 gas sensor; the MQ-135 requires burn-in calibration and cannot measure PM2.5 particulates. Ensure your Waveshare display is the V2 variant, as the V1 uses a different SPI initialization sequence that will brick the display buffer.

Component	Exact Variant / Model	Interface	Approx. Price (2026)
Microcontroller	Raspberry Pi Zero 2 W (with pre-soldered 40-pin header)	N/A	$15.00
Env Sensor	Adafruit BME688 Breakout (Product ID: 5046)	I2C	$19.95
Particulate Sensor	Plantower PMS5003 (with 12-pin to 8-pin adapter cable)	UART (3.3V)	$29.99
Display	Waveshare 2.7" V2 E-Ink (264x176, Black/White)	SPI	$24.99

GPIO Pin Mapping Table

This mapping uses BCM (Broadcom) numbering, which is the standard for modern Python libraries via adafruit-blinka. Physical pin numbers are provided for your wiring harness.

Function	BCM Pin	Physical Pin	Target Module
3.3V Power	-	1, 17	BME688, PMS5003 (VCC)
5V Power	-	2, 4	PMS5003 (Requires 5V for fan)
Ground	-	6, 9, 14	All Modules (GND)
I2C SDA	2	3	BME688
I2C SCL	3	5	BME688
UART RX	15	10	PMS5003 (TX)
UART TX	14	8	PMS5003 (RX)
SPI MOSI	10	19	E-Ink (DIN)
SPI SCLK	11	23	E-Ink (CLK)
SPI CS0	8	24	E-Ink (CS)
E-Ink DC	25	22	E-Ink (DC)
E-Ink RST	17	11	E-Ink (RST)
E-Ink BUSY	24	18	E-Ink (BUSY)

Step-by-Step Assembly & OS Configuration

The most common failure point in Pi hardware projects happens before a single line of Python is written: bus contention and serial console interference.

1. Flash the OS: Use Raspberry Pi Imager to flash Raspberry Pi OS Lite (64-bit, Bookworm) to a high-endurance 32GB microSD card. Enable SSH and configure WiFi in the advanced settings.
2. Disable Serial Console: SSH into the Pi. Run sudo raspi-config → Interface Options → Serial Port. Select No for login shell over serial, and Yes for serial port hardware enabled. If you skip this, the Linux kernel boot logs will spam the PMS5003 UART, causing buffer overflows.
3. Enable SPI and I2C: In the same raspi-config menu, enable both SPI and I2C interfaces.
4. Install Dependencies: Update your package manager and install the required Python virtual environment tools and system libraries:

   sudo apt update
   sudo apt install python3-venv python3-pip python3-smbus libopenjp2-7
   mkdir ~/aqi-monitor && cd ~/aqi-monitor
   python3 -m venv venv
   source venv/bin/activate
   pip install adafruit-blinka adafruit-circuitpython-bme680 adafruit-circuitpython-pm25 paho-mqtt Pillow

5. Wire the Hardware: Connect the modules according to the pin mapping table above. Use a logic level shifter or ensure your PMS5003 breakout board has an onboard 3.3V regulator for the RX/TX lines. The Pi's GPIO is strictly 3.3V tolerant; feeding 5V UART into BCM 15 will permanently destroy the Pi Zero 2 W's SoC.

Python Control Code & MQTT Integration

This script targets the Raspberry Pi Zero 2 W running Pi OS Bookworm. It initializes the I2C and UART buses, reads the sensor data, renders a bitmap to the E-Ink display, and publishes the payload to an MQTT broker for Home Assistant integration.

import time
import board
import busio
import digitalio
import serial
import json
import paho.mqtt.client as mqtt
from PIL import Image, ImageDraw, ImageFont
from adafruit_bme680 import Adafruit_BME680_I2C
from adafruit_pm25.uart import PM25_UART

# --- PIN DEFINITIONS & BUS INITIALIZATION ---
# I2C Setup for BME688
i2c = busio.I2C(board.SCL, board.SDA)

# UART Setup for PMS5003 (Serial0 is mapped to GPIO 14/15)
uart = serial.Serial("/dev/serial0", baudrate=9600, timeout=2)

# SPI & Control Pins for Waveshare E-Ink (using Pillow for buffer rendering)
# Note: Actual Waveshare library requires specific SPI initialization 
# Here we define the control pins for the display driver
EPD_DC = digitalio.DigitalInOut(board.D25)
EPD_RST = digitalio.DigitalInOut(board.D17)
EPD_BUSY = digitalio.DigitalInOut(board.D24)

# MQTT Configuration
MQTT_BROKER = "192.168.1.50"
MQTT_PORT = 1883
MQTT_TOPIC = "home/environmental/aqi_monitor"

client = mqtt.Client()

def init_sensors():
    """Initialize sensors with explicit error handling for bus failures."""
    try:
        bme = Adafruit_BME680_I2C(i2c, address=0x77)
        print("BME688 initialized on I2C address 0x77")
    except ValueError:
        # Fallback to alternate I2C address if SDO pin is grounded
        bme = Adafruit_BME680_I2C(i2c, address=0x76)
        print("BME688 initialized on I2C address 0x76")
    
    pm25 = PM25_UART(uart)
    return bme, pm25

def read_and_publish(bme, pm25):
    """Read sensor data, format payload, and publish to MQTT."""
    try:
        # Read BME688
        temp_c = bme.temperature
        humidity = bme.relative_humidity
        pressure = bme.pressure
        voc = bme.VOC  # Volatile Organic Compounds in Ohms
        
        # Read PMS5003
        aq_data = pm25.read()
        pm25_val = aq_data["pm25 standard"]
        
        payload = {
            "temperature": round(temp_c, 1),
            "humidity": round(humidity, 1),
            "pressure": round(pressure, 1),
            "voc_ohms": round(voc, 0),
            "pm25": pm25_val
        }
        
        client.publish(MQTT_TOPIC, json.dumps(payload))
        print(f"Published: {payload}")
        return payload
        
    except RuntimeError as e:
        print(f"Sensor read error (checksum/timeout): {e}")
        return None

def update_epink_display(data):
    """Render data to an image buffer (Waveshare EPD driver logic omitted for brevity)."""
    image = Image.new('1', (264, 176), 255)  # 1-bit color, white background
    draw = ImageDraw.Draw(image)
    font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", 24)
    
    if data:
        draw.text((10, 10), f"PM2.5: {data['pm25']} ug/m3", font=font, fill=0)
        draw.text((10, 50), f"Temp:  {data['temperature']} C", font=font, fill=0)
        draw.text((10, 90), f"Hum:   {data['humidity']} %", font=font, fill=0)
        draw.text((10, 130), f"VOC:   {data['voc_ohms']} Ohm", font=font, fill=0)
    else:
        draw.text((10, 80), "SENSOR ERROR", font=font, fill=0)
        
    # In a production script, pass 'image' to the Waveshare epd2in7_V2.display() function
    print("E-Ink buffer rendered.")

if __name__ == "__main__":
    client.connect(MQTT_BROKER, MQTT_PORT, 60)
    client.loop_start()
    
    bme_sensor, pm25_sensor = init_sensors()
    
    try:
        while True:
            data = read_and_publish(bme_sensor, pm25_sensor)
            update_epink_display(data)
            # Sleep for 5 minutes to prevent E-Ink burn-in and save power
            time.sleep(300)
    except KeyboardInterrupt:
        client.loop_stop()
        print("Monitor shut down gracefully.")

Debugging: Fixing "Permission denied: '/dev/spidev0.0'"

When working with SPI displays on the Pi, you will inevitably encounter hardware permission errors. If your script crashes immediately upon trying to initialize the E-Ink display, you will see this exact error string:

PermissionError: [Errno 13] Permission denied: '/dev/spidev0.0'

Ranked Causes & Solutions

1. User lacks SPI group permissions (Most Common): Pi OS Bookworm tightened security. The default pi user is no longer automatically granted raw hardware access.
   Fix: Run sudo usermod -a -G spi,gpio,i2c,dialout $USER, then completely log out and back in (or reboot).
2. SPI Device Tree Overlay Disabled: The kernel isn't loading the spidev module.
   Fix: Open /boot/firmware/config.txt (Note: Bookworm moved this from /boot/config.txt) and ensure the line dtparam=spi=on is present and uncommented. Reboot.
3. SPI Bus Locked by Another Process: A rogue process or previous crashed Python script is holding the file descriptor open.
   Fix: Run sudo fuser -v /dev/spidev0.0 to find the PID, then sudo kill -9 <PID>.

Extending or Simplifying the Build

Not every deployment requires a full sensor suite or a complex MQTT backend. Here is how to adapt this project to your specific constraints.

How to Simplify

• Drop the PMS5003: If you only care about indoor VOCs, temperature, and humidity, remove the PMS5003. This eliminates the UART complexity, removes the need for a 5V fan power rail, and drops the BOM cost by $30.
• Swap E-Ink for a 16x2 I2C LCD: Waveshare E-Ink displays require a 3-wire SPI protocol that can be finicky to debug. A standard HD44780-based 16x2 I2C LCD (using the lcd2usb or smbus2 libraries) plugs directly into the BME688's I2C bus, requiring only 4 wires total for the entire project.

How to Extend

• Home Assistant Auto-Discovery: Modify the MQTT payload to include Home Assistant discovery topics. By publishing a retained message to homeassistant/sensor/aqi_pm25/config, Home Assistant will automatically create the entity without manual YAML configuration.
• Add Solar & Battery: Integrate a PiJuice Zero HAT. This adds a 3.7V LiPo battery management system and a real-time clock (RTC), allowing the Pi to deep-sleep between 5-minute sensor readings, making the unit entirely wireless and solar-runnable.

FAQ: More Interesting Things to Do With Raspberry Pi

What are the most interesting things to do with Raspberry Pi for home automation?

Beyond basic smart plugs, the most valuable home automation projects involve local processing to preserve privacy. Running Home Assistant OS natively on a Pi 4 or Pi 5 is the gold standard. For edge nodes, building ESP32-based sensors that report to a Pi running an MQTT Broker (Mosquitto) and Zigbee2MQTT (using a Sonoff Zigbee 3.0 USB Dongle Plus) allows you to integrate hundreds of low-power sensors without relying on cloud servers.

Are there interesting things to do with Raspberry Pi involving AI and computer vision?

Yes. With the release of the Raspberry Pi AI Kit (featuring the Hailo-8L NPU), the Pi 5 can now run real-time object detection models like YOLOv8 at 30+ FPS. A highly practical project is building a local package delivery camera using Frigate NVR. It processes the RTSP stream from your doorbell locally, triggers an MQTT event when a specific uniform (like UPS or FedEx) is detected, and bypasses the need for expensive cloud-based AI subscriptions.

What are interesting things to do with Raspberry Pi Zero 2 W specifically?

The Zero 2 W's superpower is its low idle power draw (~0.7W) combined with quad-core processing. It is the perfect board for headless network utilities. Interesting projects include building a portable Pi-hole DNS sinkhole for travel, a Flipper Zero alternative using a custom RFID/NFC HAT, or a wardriving rig utilizing the onboard WiFi and a GPS HAT to map local wireless networks for security auditing. Because it fits in a mint tin, it excels in physical penetration testing and portable IoT deployments.