Build a Low-Latency Raspberry Pi Camera Server with Picamera2 and Flask

The Verdict: Which Raspberry Pi and Camera Module to Choose

When building a Raspberry Pi camera server, selecting the right board and sensor combination dictates your maximum resolution, frame rate, and encoding overhead. The legacy picamera library is officially deprecated on Raspberry Pi OS Bookworm; all modern builds must use the libcamera stack via picamera2.

Hardware BOM and CSI Pin Mapping

A frequent point of failure for builders migrating from Pi 4 to Pi 5 is the CSI connector. The Pi 5 uses a smaller 16-pin 0.5mm pitch connector, while the Camera Module 3 ships with a standard 15-pin 1mm cable. You must procure the specific adapter cable.

Parts List (Exact Variants)

• Board: Raspberry Pi 5 (4GB RAM) - ~$60
• Sensor: Raspberry Pi Camera Module 3 (Standard or Wide) - ~$30
• Cable: Raspberry Pi 5 Camera Cable (15-pin 1mm to 16-pin 0.5mm, 200mm) - ~$5
• Power: Official 27W USB-C PD Power Supply (Required for Pi 5 to prevent brownouts under camera load) - ~$12
• Storage: 32GB SanDisk Extreme microSD (A1 rated for minimum I/O latency) - ~$12

CSI-2 Connector Pin Mapping (Pi 5 16-Pin MIPI)

While you do not wire individual pins manually, understanding the MIPI CSI-2 mapping helps when debugging signal integrity or using third-party extension boards.

Software Setup: Picamera2 and Flask Streaming

Target Board Variant: Raspberry Pi 5 (4GB) running Raspberry Pi OS (64-bit, Bookworm).

We use picamera2 for hardware-accelerated sensor control and Flask to serve the MJPEG stream over HTTP. Flask is chosen over raw socket servers because it allows easy integration with REST APIs for PTZ (Pan-Tilt-Zoom) control later.

The Python Streaming Server Code

The following code initializes the IMX708 sensor, configures a 720p video stream to minimize encoding latency, and serves it via a Flask route. It includes robust error handling for camera initialization and thread-safe frame generation.

import cv2
import time
import logging
from flask import Flask, Response
from picamera2 import Picamera2
from picamera2 import MappedArray
import threading

# Configure logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

app = Flask(__name__)
picam2 = None
output_frame = None
lock = threading.Lock()

def initialize_camera():
    global picam2
    try:
        picam2 = Picamera2()
        # Configure for 720p at 30fps to balance latency and bandwidth
        video_config = picam2.create_video_configuration(main={'size': (1280, 720), 'format': 'XRGB8888'})
        picam2.configure(video_config)
        picam2.start()
        time.sleep(2.0)  # Allow camera auto-exposure to settle
        logging.info('Camera initialized successfully.')
    except Exception as e:
        logging.error(f'Failed to initialize camera: {e}')
        raise

def generate_frames():
    global output_frame, lock
    while True:
        if picam2 is None:
            time.sleep(0.1)
            continue
            
        # Capture array directly from libcamera buffer
        frame = picam2.capture_array()
        
        # Convert XRGB8888 to BGR for OpenCV encoding
        frame_bgr = cv2.cvtColor(frame, cv2.COLOR_RGBA2BGR)
        
        # Encode frame as JPEG
        ret, buffer = cv2.imencode('.jpg', frame_bgr, [cv2.IMWRITE_JPEG_QUALITY, 80])
        if not ret:
            continue
            
        frame_bytes = buffer.tobytes()
        
        with lock:
            output_frame = frame_bytes
            
        # Yield frame in MJPEG format
        yield (b'--frame\r\n'
               b'Content-Type: image/jpeg\r\n\r\n' + frame_bytes + b'\r\n')

@app.route('/video_feed')
def video_feed():
    return Response(generate_frames(),
                    mimetype='multipart/x-mixed-replace; boundary=frame')

@app.route('/')
def index():
    return '<h1>Raspberry Pi Camera Server</h1><img src="/video_feed" width="100%">'

if __name__ == '__main__':
    try:
        initialize_camera()
        # Bind to 0.0.0.0 to allow LAN access, port 8000
        app.run(host='0.0.0.0', port=8000, threaded=True, debug=False)
    except KeyboardInterrupt:
        logging.info('Server shutting down.')
    finally:
        if picam2:
            picam2.stop()
            logging.info('Camera resources released.')

Debugging: Exact Error Strings and Ranked Causes

When your Raspberry Pi camera server fails to start, the libcamera stack throws specific errors. Here is how to diagnose them.

The First Three Things to Check

1. Cable Orientation and Seating: The blue tape on the CSI flex cable must face away from the board (towards the edge) on the Pi 5. Ensure the cable is fully inserted before locking the latch.
2. Driver Loading: Run libcamera-hello --list-cameras. If this fails, the OS cannot see the sensor on the I2C bus, meaning it is a physical connection issue, not a Python code issue.
3. Legacy Camera Mode: Ensure start_x=1 or legacy_camera is NOT enabled in /boot/firmware/config.txt. The legacy stack blocks libcamera from accessing the MIPI hardware.

Ranked Causes for Common Error Strings

Error String: ERROR: *** no cameras available ***

• Cause 1 (Most Likely): You are using the standard 15-pin cable from the Camera Module 3 box on a Pi 5. Fix: Buy the 16-pin 0.5mm Pi 5 adapter cable.
• Cause 2: The I2C EEPROM on the camera module cannot be read due to a loose connection. Fix: Reseat the cable and check for bent pins.
• Cause 3: The camera is connected to a third-party HAT that lacks the necessary I2C pass-through. Fix: Connect directly to the Pi's native CSI port for testing.

Error String: mmal: mmal_vc_port_enable: failed to enable port vc.null_sink:in:o(OPQV)

• Cause 1: You are trying to import the legacy picamera library instead of picamera2 on Raspberry Pi OS Bookworm. Fix: Rewrite your code using the picamera2 API provided above.
• Cause 2: A zombie libcamera process is holding the MIPI device node open. Fix: Run sudo pkill -9 python3 and sudo pkill -9 libcamera, then reboot.

Error String: OSError: [Errno 98] Address already in use

• Cause 1: A previous instance of the Flask server crashed without releasing port 8000. Fix: Run sudo lsof -i :8000 to find the PID, then sudo kill -9 <PID>.

Extending and Simplifying the Build

Depending on your end goal, you may need to alter the architecture of this server.

How to Simplify (Lower Latency)

If your goal is pure FPV (First Person View) streaming or machine vision where HTTP overhead is unacceptable, drop Flask entirely. Use ustreamer or mjpeg-streamer. These are C-based daemons that read directly from the V4L2 buffer and push MJPEG frames over raw sockets, reducing latency from ~150ms (Flask) to ~40ms.

How to Extend (Add Motion Detection and PTZ)

To extend this build into a full security node:

• MQTT Integration: Add the paho-mqtt library. Inside the generate_frames() loop, calculate the absolute difference between the current frame and the previous frame using cv2.absdiff. If the delta exceeds a threshold, publish a payload to your MQTT broker.
• Pan/Tilt Control: Wire a Pimoroni Pan-Tilt HAT to the 40-pin GPIO header. Because the HAT uses I2C, it will not conflict with the MIPI CSI-2 camera pins. Add a Flask /api/pan route that accepts degree values and commands the HAT servos.

By standardizing on the Pi 5, the IMX708 sensor, and the picamera2 library, you eliminate the driver conflicts that plagued older Raspberry Pi camera server builds, resulting in a stable, production-ready video node.