Raspberry Pi Home Security: Build a Local AI Motion Camera

Building a custom raspberry pi home security node gives you something commercial cloud cameras cannot: zero subscription fees, total local privacy, and direct GPIO control for physical alarms. But the jump from a basic webcam script to a reliable, always-on security node requires navigating the Pi 5's new camera stack and handling hardware interrupts without locking up the OS.

This guide targets the Raspberry Pi 5 (4GB variant) running Raspberry Pi OS Bookworm (64-bit). We will wire a hardware PIR sensor to trigger the Raspberry Pi Camera Module 3, capture a high-res still, and fire a 12V DC piezo siren via a relay—all while keeping the system resilient against the most common libcamera crashes.

The Decision Matrix: Which Raspberry Pi Home Security Path to Take

Before cutting wires, you need to pick your architecture. Most builders default to whatever tutorial they find first, which usually leads to abandoned projects when the SD card corrupts or the WiFi drops. Use this decision tree to lock in your approach.

For this build, we are executing the Standalone Pi Node. It terminates in a concrete, self-contained hardware pick that operates entirely offline if your network goes down.

Hardware Spec Sheet and Pin Mapping

The Pi 5 draws significantly more current than the Pi 4, especially when the camera ISP and GPIO pins are active simultaneously. Do not use a standard 15W phone charger; the camera module will brownout when the relay kicks in.

GPIO Pin Mapping

We are using hardware PWM-capable and standard GPIO pins. Ensure your PIR sensor is a 3.3V variant (like the AM312); feeding 5V from an HC-SR501 into a Pi 5 GPIO will fry the SoC.

Step-by-Step Assembly and Wiring

1. Prep the OS: Flash Raspberry Pi OS Bookworm (64-bit, Lite or Desktop) using Raspberry Pi Imager. Enable SSH and configure your WiFi in the imager settings.
2. Seat the Camera: Connect the CSI ribbon cable to the Pi 5 and the Camera Module 3. Boot the Pi and run libcamera-hello in the terminal to verify the ISP sees the sensor.
3. Wire the PIR: Connect the AM312 VCC to Pi Pin 2 (5V), GND to Pin 6, and OUT to Pin 11 (GPIO 17). The AM312 has an onboard LDO that safely steps the 5V down to 3.3V for the logic output.
4. Wire the Relay: Connect Relay VCC to Pin 2 (5V), GND to Pin 6, and IN to Pin 13 (GPIO 27).
   Safety Warning: For this build, wire the relay's COM and NO (Normally Open) terminals to a 12V DC piezo siren and a 12V DC power adapter. Never use a hobbyist 5V relay module to switch 120V/240V AC mains for a siren; the contact gaps are insufficient and pose a severe arc-flash and fire risk. Leave mains switching to rated contactors and licensed electricians.
5. Install Dependencies: Update your environment and install the required Python libraries:
   sudo apt update && sudo apt install python3-picamera2 python3-gpiozero python3-numpy -y

The Python Code: Motion Detection and Alert Trigger

This script uses the modern picamera2 library (the legacy picamera library is deprecated on Bookworm). It initializes the camera, waits for a hardware interrupt from the PIR, snaps a high-res JPEG, and fires the relay.

import time
import signal
import sys
import os
from datetime import datetime
from picamera2 import Picamera2
from gpiozero import MotionSensor, OutputDevice

# --- PIN DEFINITIONS ---
PIR_PIN = 17
RELAY_PIN = 27
SAVE_DIR = '/home/pi/security_captures'

# Ensure save directory exists
os.makedirs(SAVE_DIR, exist_ok=True)

# Initialize Hardware
pir = MotionSensor(PIR_PIN, queue_len=1, threshold=0.5)
# Most hobby relays are Active Low (trigger on GND)
relay = OutputDevice(RELAY_PIN, active_high=False)

def graceful_exit(sig, frame):
    print('\n[INFO] Shutting down gracefully...')
    relay.off()
    pir.close()
    sys.exit(0)

signal.signal(signal.SIGINT, graceful_exit)
signal.signal(signal.SIGTERM, graceful_exit)

def capture_and_alarm():
    timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
    filepath = os.path.join(SAVE_DIR, f'intruder_{timestamp}.jpg')
    
    print(f'[ALERT] Motion detected! Triggering alarm and capturing image...')
    
    # Fire the 12V siren
    relay.on()
    
    try:
        # Switch to high-res mode for the capture
        picam2.switch_mode_and_capture_file(picam2.still_configuration, filepath)
        print(f'[OK] Saved capture to {filepath}')
    except Exception as e:
        print(f'[ERROR] Camera capture failed: {e}')
    finally:
        # Keep siren on for 3 seconds, then cut
        time.sleep(3)
        relay.off()
        # Cooldown to prevent rapid-fire relay clicking
        time.sleep(5)

def main():
    global picam2
    try:
        picam2 = Picamera2()
        # Configure a low-res preview stream to save CPU, keep high-res for stills
        picam2.configure(picam2.create_preview_configuration(main={'size': (640, 480)})
        )
        picam2.start()
        print('[INFO] Camera initialized. Waiting for motion...')
    except RuntimeError as e:
        print(f'[FATAL] Camera init failed: {e}')
        sys.exit(1)

    # Bind PIR hardware interrupt to our function
    pir.when_motion = capture_and_alarm

    # Keep main thread alive
    while True:
        time.sleep(1)

if __name__ == '__main__':
    main()

Troubleshooting: Fatal Camera and GPIO Errors

When building a raspberry pi home security node, you will inevitably hit the camera stack's strict hardware locking. Here is how to debug the most common fatal errors.

Exact Error: RuntimeError: Failed to acquire camera handle: Device or resource busy

What it means: The libcamera daemon or another process currently holds the CSI bus lock. The Pi camera hardware only allows one active stream at a time.

Ranked Causes & Fixes:

1. Orphaned Process (Most Likely): You ran a test script and hit Ctrl+C before the picam2.close() or GPIO cleanup routine fired, leaving the camera node locked.
   Fix: Run sudo pkill -f libcamera and sudo pkill -f python, then reboot.
2. Cron Job Collision: You have a timelapse cron job running libcamera-still in the background.
   Fix: Check crontab -e and disable conflicting camera tasks.
3. Insufficient Power Brownout: The Pi 5 requires a 27W USB-C PD supply. If you use a 15W charger, the voltage drops when the relay coil energizes, causing the camera ISP to crash and drop the handle.
   Fix: Verify you are using the official 27W Pi power supply. Check dmesg | grep -i voltage for undervoltage warnings.

The First Three Things to Check When It Fails

Extending and Simplifying the Build

Once the baseline hardware trigger is stable, you can adapt the node to fit your specific environment.

How to Extend (Add AI and Network Alerts)

• Add MQTT for Home Assistant: Install paho-mqtt and publish a JSON payload to your broker inside the capture_and_alarm() function. This allows Home Assistant to display the captured JPEG on your dashboard instantly.
• Upgrade to Frigate NVR: If you decide you need 24/7 buffer recording and AI person-detection, abandon the custom Python script. Install Frigate NVR via Docker on the Pi 5. You will need to add a Coral USB Accelerator ($35) to handle the TensorFlow inference without pegging the Pi's CPU.

How to Simplify (Drop the Hardware Alarm)

If you are deploying this in an apartment where a 12V piezo siren will just annoy your neighbors, strip the relay out entirely. Replace the relay.on() block with a simple HTTPS POST request using the requests library to send the captured JPEG to a free Telegram Bot API or a Discord webhook. This reduces your BOM cost by $15, eliminates the 5V relay click noise, and removes the risk of GPIO lockups caused by cheap optocoupler back-EMF.

For a dedicated, offline entry-point alarm, the Pi 5 with a hardware PIR and local picamera2 capture remains the most responsive and private architecture available. Stick to the 27W power supply, keep your ribbon cable seated, and let the hardware interrupts do the heavy lifting.