Multi-Camera Setup on Raspberry Pi: Complete Guide to Stereo Vision & Monitoring

Multi-camera systems unlock advanced capabilities like stereo vision, 360-degree monitoring, and synchronized multi-angle capture. This guide covers hardware options, Arducam multiplexer configurations, and software approaches for building robust multi-camera solutions on Raspberry Pi.

Hardware Options and Limitations

The Raspberry Pi has limited native camera interfaces, requiring specialized hardware for multi-camera setups:

Arducam Multiplexer Setup

The Arducam Multi-Camera Adapter enables connecting up to 4 cameras to a single CSI port:

Hardware Installation

# Physical Connection Steps
1. Power off Raspberry Pi completely
2. Connect multiplexer board to Pi CSI port
3. Connect cameras to multiplexer ports (A, B, C, D)
4. Ensure ribbon cables are seated properly
 - Blue side faces away from board on Pi
 - Silver contacts face the board

# Enable Camera in config.txt
sudo nano /boot/firmware/config.txt

# Add these lines:
dtoverlay=arducam-pivariety
camera_auto_detect=0

# Reboot
sudo reboot

Software Configuration

# Install Arducam driver and libraries
cd ~
wget -O install_pivariety_pkgs.sh https://github.com/ArduCAM/Arducam-Pivariety-V4L2-Driver/releases/download/install_script/install_pivariety_pkgs.sh
chmod +x install_pivariety_pkgs.sh
./install_pivariety_pkgs.sh -p libcamera_dev
./install_pivariety_pkgs.sh -p libcamera_apps

# Test camera switching
# Switch to Camera A (port 0)
i2cset -y 10 0x24 0x24 0x02
libcamera-still -o test_cam_a.jpg

# Switch to Camera B (port 1) 
i2cset -y 10 0x24 0x24 0x12
libcamera-still -o test_cam_b.webp

Stereo Vision Configuration

Stereo vision requires precisely calibrated parallel cameras for depth perception:

Python Stereo Capture Code

import cv2
import numpy as np
from picamera2 import Picamera2
import subprocess

class StereoCamera:
 def __init__(self):
 self.picam = Picamera2()
 config = self.picam.create_still_configuration(
 main={"size": (1920, 1080)}
 )
 self.picam.configure(config)
 
 def switch_camera(self, port):
 """Switch multiplexer to specified port (0-3)"""
 port_values = {0: 0x02, 1: 0x12, 2: 0x22, 3: 0x32}
 cmd = f"i2cset -y 10 0x24 0x24 {hex(port_values[port])}"
 subprocess.run(cmd.split(), check=True)
 
 def capture_stereo_pair(self):
 """Capture synchronized left/right images"""
 self.picam.start()
 
 # Capture left camera
 self.switch_camera(0)
 left = self.picam.capture_array()
 
 # Capture right camera
 self.switch_camera(1)
 right = self.picam.capture_array()
 
 self.picam.stop()
 return left, right
 
 def compute_disparity(self, left, right):
 """Calculate disparity map for depth estimation"""
 # Convert to grayscale
 left_gray = cv2.cvtColor(left, cv2.COLOR_BGR2GRAY)
 right_gray = cv2.cvtColor(right, cv2.COLOR_BGR2GRAY)
 
 # Create stereo matcher
 stereo = cv2.StereoSGBM_create(
 minDisparity=0,
 numDisparities=128,
 blockSize=11,
 P1=8 * 3 * 11**2,
 P2=32 * 3 * 11**2,
 disp12MaxDiff=1,
 uniquenessRatio=10,
 speckleWindowSize=100,
 speckleRange=32
 )
 
 disparity = stereo.compute(left_gray, right_gray)
 return disparity

# Usage
camera = StereoCamera()
left, right = camera.capture_stereo_pair()
depth = camera.compute_disparity(left, right)

360-Degree Monitoring System

Create comprehensive surveillance coverage using four cameras positioned at 90-degree intervals:

 [Cam A - North]
 |
 [Cam D]------+------[Cam B]
 West | East
 |
 [Cam C - South]
 
 Each camera: 90° FOV = Full 360° coverage
 Overlap zones: Better stitching accuracy
 

Motion Detection Monitoring Script

#!/usr/bin/env python3
"""Multi-camera motion detection monitoring system"""

import cv2
import time
from datetime import datetime
from threading import Thread, Lock
import queue

class CameraMonitor:
 def __init__(self, num_cameras=4):
 self.num_cameras = num_cameras
 self.frames = {}
 self.prev_frames = {}
 self.motion_threshold = 5000
 self.recording = False
 self.lock = Lock()
 
 def detect_motion(self, current, previous, camera_id):
 """Compare frames to detect significant motion"""
 if previous is None:
 return False
 
 diff = cv2.absdiff(current, previous)
 gray = cv2.cvtColor(diff, cv2.COLOR_BGR2GRAY)
 blur = cv2.GaussianBlur(gray, (21, 21), 0)
 _, thresh = cv2.threshold(blur, 25, 255, cv2.THRESH_BINARY)
 
 motion_pixels = cv2.countNonZero(thresh)
 
 if motion_pixels > self.motion_threshold:
 timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
 filename = f"motion_cam{camera_id}_{timestamp}.webp"
 cv2.imwrite(filename, current)
 print(f"Motion detected on camera {camera_id}: {filename}")
 return True
 return False
 
 def run_monitoring_cycle(self):
 """Cycle through all cameras checking for motion"""
 while True:
 for cam_id in range(self.num_cameras):
 # Switch to camera and capture
 frame = self.capture_from_camera(cam_id)
 
 with self.lock:
 prev = self.prev_frames.get(cam_id)
 self.detect_motion(frame, prev, cam_id)
 self.prev_frames[cam_id] = frame
 
 time.sleep(0.5) # Cycle delay

if __name__ == "__main__":
 monitor = CameraMonitor(num_cameras=4)
 monitor.run_monitoring_cycle()

Frame Synchronization Techniques

For applications requiring simultaneous capture, consider these synchronization approaches:

Performance Optimization

Application Ideas

Multi-camera systems on Raspberry Pi provide powerful capabilities for vision applications that would otherwise require expensive commercial solutions. With proper hardware selection and software optimization, you can build robust systems for stereo vision, monitoring, and more.