How to Make a Security Camera with Raspberry Pi 5 and Picam 3

To make a reliable, low-latency security camera with a Raspberry Pi, use the Raspberry Pi 5 (8GB) paired with the Picam 3 Wide module, running Raspberry Pi OS Bookworm 64-bit. By leveraging the Pi 5’s dedicated RP1 I/O chip and the Picam 3’s Sony IMX708 sensor, you get 12MP resolution, native HDR, and phase-detect autofocus without the USB bottleneck that plagues older webcam setups. This guide walks through the exact hardware selection, physical assembly, and a robust Python streaming implementation with full error handling.

Hardware Decision Tree: Which Pi and Camera Module?

Choosing the right compute and sensor combination prevents overbuilding or hitting bandwidth walls. Use this decision path to select your hardware:

• Do you need local AI person/vehicle detection?
  • Yes: You need the Pi 5 (8GB) to support the M.2 Hailo-8L AI accelerator.
  • No: Proceed to the next question.
• Is the camera mounted more than 15 feet from the router, requiring high-gain antennas or PoE?
  • Yes: Use the Pi 5 with an official PoE+ HAT.
  • No: Proceed to the next question.
• Do you need a wide field of view (102°+) for a small room or porch?
  • Yes: Select the Picam 3 Wide (no IR filter, or standard).
  • No: Select the standard Picam 3 (75° FOV).

Parts List & Spec Sheet

Sourcing the exact variants matters. The Pi 5 is highly sensitive to voltage drop; using a third-party 5V/3A phone charger will trigger brownout warnings and crash the camera pipeline.

Physical Assembly & CSI Pin Mapping

The Pi 5 uses two 15-pin MIPI CSI-2 connectors. Unlike the Pi 4, the Pi 5 CSI connectors are smaller (0.5mm pitch vs 1.0mm) and require the specific Picam 3 ribbon cable.

While you do not need to wire the CSI pins manually, understanding the 15-pin mapping helps when debugging I2C sensor communication failures.

Software Setup: MotionEyeOS vs. Custom Python RTSP

You have two primary software paths. MotionEyeOS is a popular pre-packaged OS, but as of 2026, its support for the Pi 5’s libcamera driver stack remains buggy, often failing to initialize the IMX708 sensor. Custom Python streaming using the official picamera2 library is the superior, decision-forward choice for the Pi 5.

The code and steps below explicitly target the Raspberry Pi 5 (8GB) running Raspberry Pi OS Bookworm (64-bit).

1. Flash the OS: Use Raspberry Pi Imager to write Raspberry Pi OS (64-bit, Bookworm) to your A2 microSD. Enable SSH and configure WiFi in the advanced settings.
2. Update and Install Dependencies: SSH into the Pi and run:

   sudo apt update && sudo apt upgrade -y
   sudo apt install -y python3-picamera2 python3-flask python3-opencv python3-gpiozero

3. Verify Hardware Link: Run libcamera-hello -t 5000. If a 5-second preview window appears (or no errors show in headless mode), your CSI connection is solid.

Complete Python Streaming Code

This script creates an MJPEG HTTP stream accessible via any web browser or NVR (like Frigate or BlueIris) using the MJPEG URL. It includes GPIO pin definitions for a status LED and robust error handling for camera initialization.

import io
import logging
import threading
import time
from flask import Flask, Response
from picamera2 import Picamera2
from picamera2.encoders import JpegEncoder
from picamera2.outputs import FileOutput
from gpiozero import LED

# --- PIN DEFINITIONS & CONFIG ---
# GPIO 17 (Physical Pin 11) connected to Red LED + 330 ohm resistor to GND
STATUS_LED_PIN = 17 
STREAM_HOST = '0.0.0.0'
STREAM_PORT = 8000

# Initialize GPIO
recording_led = LED(STATUS_LED_PIN)

# Initialize Flask
app = Flask(__name__)
logging.basicConfig(level=logging.INFO)

class StreamingOutput(io.BufferedIOBase):
    def __init__(self):
        self.frame = None
        self.condition = threading.Condition()

    def write(self, buf):
        with self.condition:
            self.frame = buf
            self.condition.notify_all()

def init_camera():
    """Initialize Picamera2 with error handling for hardware faults."""
    try:
        cam = Picamera2()
        # Configure for 1080p streaming to save bandwidth while maintaining quality
        config = cam.create_video_configuration(main={"size": (1920, 1080)})
        cam.configure(config)
        return cam
    except RuntimeError as e:
        logging.error(f"Camera initialization failed: {e}")
        return None

output = StreamingOutput()
picam2 = init_camera()

if picam2 is None:
    logging.critical("Halting: Camera hardware not detected.")
    exit(1)

@app.route('/')
def index():
    return '<h1>Pi 5 Security Stream</h1><img src="/stream.mjpg" width="100%">'

@app.route('/stream.mjpg')
def stream():
    def generate():
        recording_led.on()
        try:
            while True:
                with output.condition:
                    output.condition.wait()
                    frame = output.frame
                yield (b'--frame\r\n'
                       b'Content-Type: image/jpeg\r\n\r\n' + frame + b'\r\n')
        finally:
            recording_led.off()
            
    return Response(generate(), mimetype='multipart/x-mixed-replace; boundary=frame')

if __name__ == '__main__':
    logging.info(f"Starting MJPEG stream on http://{STREAM_HOST}:{STREAM_PORT}")
    picam2.start_recording(JpegEncoder(), FileOutput(output))
    try:
        app.run(host=STREAM_HOST, port=STREAM_PORT, threaded=True)
    finally:
        picam2.stop_recording()
        recording_led.off()

Debugging: "Camera Not Detected" & Stream Drops

When the camera pipeline fails, the libcamera stack throws specific errors. If your script crashes or libcamera-hello fails, check these first three things:

1. Ribbon Cable Seating: The 0.5mm pitch cable is notoriously finicky. Ensure it is inserted fully to the white line before locking the latch.
2. Power Supply Brownout: Check dmesg | grep -i voltage. If you see under-voltage warnings, your PSU is inadequate. The Picam 3 draws ~300mA on startup; a weak 5V supply will cause the I2C sensor handshake to fail.
3. Legacy Camera Stack Enabled: Run sudo raspi-config -> Interface Options -> Legacy Camera. Ensure this is Disabled. The legacy stack is incompatible with the Pi 5 and Picam 3.

Exact Error Strings and Ranked Causes

Extending and Simplifying the Build

Once your base stream is running, you can scale the project up or down based on your deployment environment.

How to Simplify (For Low-Power / Remote Locations)

If you are deploying on a battery bank or solar setup, the Pi 5’s 5W+ idle draw is too high. Simplify by switching to the Raspberry Pi Zero 2 W paired with the older Picam 2.1. The Zero 2 W idles around 0.7W. You will lose the IMX708’s autofocus and HDR, but the Python Flask code above remains 100% compatible (just lower the resolution to 1280x720 to prevent the Zero's RAM from bottlenecking).

How to Extend (For Smart Detection)

To convert this dumb stream into a smart security node, add the Raspberry Pi AI Kit (Hailo-8L). The Pi 5’s PCIe 2.0 interface connects directly to the Hailo NPU, allowing you to run YOLOv8 person-detection models at 13 FPS without loading the main CPU cores. You can extend the Python script to pull frames from the MJPEG stream, pass them through the Hailo inference pipeline, and trigger an MQTT alert to Home Assistant only when a human is detected, drastically reducing false positives from wind-blown trees.

For deeper integration with NVR software, consult the official Raspberry Pi Camera Software Documentation for advanced libcamera tuning parameters like exposure compensation and digital gain limits.