Choosing the Best Camera for Raspberry Pi 5: Module 3 vs HQ Setup

The transition to Raspberry Pi OS Bookworm completely changed how we interface with a camera for Raspberry Pi builds. The legacy picamera Python library is deprecated, replaced by the libcamera framework and the picamera2 Python bindings. If you are following a tutorial from 2022 or earlier, your code will fail. Furthermore, the physical connectors changed on the Pi 5, introducing a new ribbon cable requirement that catches many makers off guard.

This guide cuts through the outdated documentation. We will make a concrete hardware decision, wire a motion-triggered capture system on the Pi 5, write modern picamera2 code with proper error handling, and debug the exact libcamera errors that halt 90% of first-time builds.

The Verdict: Which Camera for Raspberry Pi Should You Buy?

Raspberry Pi currently offers three main first-party camera boards. Choosing the wrong one leads to compromised optics or blown budgets. Use this decision path to select your hardware.

Project Build: Motion-Triggered Security Capture

We are building a PIR-triggered security camera. When motion is detected, the Pi 5 wakes the sensor, captures a full-resolution still, and saves it to disk.

Parts List

• Compute: Raspberry Pi 5 (4GB minimum for full-res buffer handling)
• Camera: Raspberry Pi Camera Module 3 (IMX708)
• Cable (CRITICAL): 200mm 15-pin to 22-pin MIPI CSI adapter cable. Note: The Module 3 ships with a 15-pin cable for the Pi 4. The Pi 5 uses a smaller 22-pin 0.5mm pitch connector. You must buy the Pi 5 specific adapter cable.
• Sensor: HC-SR501 PIR Motion Sensor
• Wiring: 3x Female-to-Female jumper wires

Pin Mapping Table

The MIPI CSI-2 interface handles the camera data over dedicated high-speed differential pairs (not standard GPIO). The PIR sensor, however, uses standard digital GPIO.

Step-by-Step Wiring and Software Setup

1. Power Down: Disconnect the Pi 5 from the USB-C power supply. Never hot-plug MIPI CSI cables; you risk shorting the 3.3V I2C lines and permanently frying the camera's power management IC.
2. Connect the CSI Cable: Lift the black plastic locking collar on the Pi 5's CAM0 connector. Insert the 22-pin end of the adapter cable. Orientation: The blue tape/stiffener on the cable should face away from the USB ports (towards the edge of the board). Press the collar down to lock.
3. Connect the Camera: Attach the 15-pin end of the cable to the Camera Module 3. Blue tape faces away from the lens.
4. Wire the PIR: Connect VCC to Pin 2, GND to Pin 6, and OUT to Pin 11 (GPIO 17) as per the table above.
5. Install Dependencies: Boot the Pi, open a terminal, and install the modern Python bindings and GPIO library:

   sudo apt update
   sudo apt install python3-picamera2 python3-libcamera python3-gpiozero

Complete Python Code (Picamera2 + GPIO Zero)

This script targets the Bookworm picamera2 API. It includes explicit error handling for camera initialization failures and configures the sensor for a high-quality still capture rather than a video stream.

import time
import os
from datetime import datetime
from picamera2 import Picamera2
from gpiozero import MotionSensor

# Pin definition matching our physical wiring
PIR_PIN = 17
SAVE_DIR = "/home/pi/captures"

def setup_environment():
    if not os.path.exists(SAVE_DIR):
        os.makedirs(SAVE_DIR)

def main():
    setup_environment()
    pir = MotionSensor(PIR_PIN)
    
    print("Initializing Camera Module 3...")
    try:
        picam2 = Picamera2()
        # Configure for still capture (max resolution, low noise)
        picam2_config = picam2.create_still_configuration()
        picam2.configure(picam2_config)
        picam2.start()
        print("Camera initialized successfully. Waiting for motion...")
    except RuntimeError as e:
        print(f"CRITICAL ERROR: Failed to initialize camera.\nDetails: {e}")
        print("Check CSI cable orientation and ensure legacy camera stack is disabled.")
        return

    try:
        while True:
            pir.wait_for_motion(timeout=None) # Blocks until motion is detected
            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
            filepath = os.path.join(SAVE_DIR, f"motion_{timestamp}.jpg")
            
            print(f"Motion detected! Capturing to {filepath}...")
            # capture_file blocks until the frame is processed and saved
            picam2.capture_file(filepath)
            
            # Cooldown to prevent filling the SD card with burst photos
            time.sleep(5) 
            pir.wait_for_no_motion(timeout=5)
            
    except KeyboardInterrupt:
        print("\nScript terminated by user.")
    finally:
        picam2.stop()
        print("Camera resources released.")

if __name__ == "__main__":
    main()

Debugging: 'No cameras available' and libcamera Errors

When migrating to libcamera, hardware and config mismatches throw specific, often confusing errors. Here is how to debug the two most common failure modes.

Error 1: The libcamera Initialization Failure

Exact Error String:

[0:12:34.567890] ERROR Camera camera_manager.cpp:284 : No cameras available!
RuntimeError: Failed to initialize camera.

Ranked Causes & Fixes:

1. Legacy Camera Stack is Enabled (Most Common): The old start_x=1 firmware driver conflicts with libcamera. Fix: Run sudo raspi-config -> Interface Options -> Legacy Camera -> Disable. Reboot.
2. Incorrect CSI Cable Orientation: The MIPI lanes are crossed. Fix: Power down, flip the cable at the board connector so the blue stiffener faces the correct edge, and reseat.
3. Missing I2C Connection: The Pi uses I2C to read the camera's EEPROM. If the tiny I2C pins inside the CSI connector are bent, the OS cannot identify the IMX708 sensor. Fix: Inspect the FPC connector with a magnifying glass for bent pins.

Error 2: Buffer Allocation Failure

Exact Error String:

RuntimeError: Failed to allocate buffers

Cause: You are running a Pi 5 with 2GB of RAM, or your GPU memory split is misconfigured, and requesting a 12MP still buffer (which requires ~50MB of contiguous DMA memory) is failing. Fix: Add dtoverlay=vc4-kms-v3d,cma-512 to your /boot/firmware/config.txt to allocate a larger Contiguous Memory Allocator pool, or drop the configuration to picam2.create_preview_configuration() if you only need 1080p.

Extending and Simplifying the Build

Once the baseline capture is working, you can adapt the architecture to fit your specific deployment environment.

How to Simplify (The Cron + Timelapse Route)

If you don't need motion triggering and just want a daily weather timelapse, strip out gpiozero and the while True loop. Write a script that captures a single frame and exits. Then, use crontab -e to schedule it:

# Capture one image every hour at minute 0
0 * * * * /usr/bin/python3 /home/pi/timelapse.py

This eliminates the need for a PIR sensor, reduces power consumption, and prevents memory leaks from long-running Python processes.

How to Extend (MQTT and Remote Alerts)

To turn this into a true IoT security node, integrate the paho-mqtt library. Inside the motion detection block, after capture_file(), publish the image path or a base64-encoded thumbnail to an MQTT broker (like Mosquitto or Adafruit IO).

import paho.mqtt.client as mqtt
client = mqtt.Client()
client.connect("192.168.1.100", 1883, 60)
# Inside the loop:
client.publish("home/security/cam01", f"Motion captured: {filepath}")

For advanced computer vision, swap the capture_file() method for capture_array(), which returns a NumPy array. You can pass this array directly into OpenCV (cv2) or a TensorFlow Lite interpreter to classify the motion (e.g., "Person" vs "Stray Cat") before deciding whether to save the file or send an alert.

For deeper technical specifications on the IMX708 sensor tuning and libcamera pipeline configurations, refer to the official Picamera2 GitHub repository and the Raspberry Pi Camera Software Documentation.