Własna kamera bezpieczeństwa z AI – bez chmury, bez abonamentu

Problem: miesięczny abonament za własny dom

Ring, Nest Cam, Arlo – każdy z tych systemów pobiera 8–30 dolarów miesięcznie za możliwość przeglądania nagrań sprzed doby. Twoje nagrania trafiają na serwery Amazon, Google i innych gigantów. Czy naprawdę chcesz, żeby obcy serwer wiedział, o której wychodzisz do pracy?

Dobra wiadomość: za jednorazowy koszt sprzętu (200–400 zł) możesz zbudować system, który nigdy nie wysyła danych poza dom, przechowuje nagrania lokalnie i działa nawet bez internetu.

Lista zakupów

Podejście A: Frigate NVR + Home Assistant (zaawansowane)

Frigate to otwartoźródłowy serwer NVR z wbudowaną detekcją obiektów. Działa jako kontener Docker i integruje się z Home Assistant, dając pełny system inteligentnego domu.

Instalacja Frigate (Docker Compose)

# Zainstaluj Docker na Raspberry Pi OS
curl -fsSL https://get.docker.com | sh
sudo usermod -aG docker $USER

# Utwórz katalog projektu
mkdir ~/frigate && cd ~/frigate
nano docker-compose.yml

version: "3.9"
services:
  frigate:
    image: ghcr.io/blakeblackshear/frigate:stable
    privileged: true
    restart: unless-stopped
    ports:
      - "5000:5000"   # Web UI
      - "8554:8554"   # RTSP
    volumes:
      - ./config:/config
      - ./storage:/media/frigate
      - /etc/localtime:/etc/localtime:ro
    environment:
      FRIGATE_RTSP_PASSWORD: "twoje_haslo"

# Plik config/config.yml
mqtt:
  enabled: false

cameras:
  kamera_wejscie:
    ffmpeg:
      inputs:
        - path: rtsp://admin:twoje_haslo@192.168.1.100:554/stream1
          roles:
            - detect
            - record
    detect:
      enabled: true
      width: 1280
      height: 720
      fps: 5
    record:
      enabled: true
      retain:
        days: 7
        mode: motion
    snapshots:
      enabled: true
      retain:
        default: 14
    objects:
      track:
        - person
        - car
        - dog

detectors:
  cpu1:
    type: cpu
    num_threads: 3

# Uruchomienie
docker compose up -d

# Sprawdź logi
docker compose logs -f frigate

Po 2–3 minutach otwórz w przeglądarce http://adres-raspberry-pi:5000 – zobaczysz panel Frigate z podglądem na żywo i zdarzeniami.

Powiadomienia przez Telegram (bez opłat)

# W Home Assistant (jeśli masz) dodaj automatyzację:
# Trigger: Frigate event (person detected)
# Action: Telegram notification z załączonym zdjęciem

Podejście B: Python + YOLOv8 (prostsze, pełna kontrola)

Jeśli nie chcesz Home Assistant i wolisz prosty skrypt Pythona, to podejście jest dla Ciebie. Idealne dla ESP32-CAM lub zwykłej kamery USB.

Instalacja

sudo apt update && sudo apt install -y python3-pip python3-venv git
python3 -m venv ~/ai-kamera
source ~/ai-kamera/bin/activate
pip install ultralytics opencv-python-headless requests

Skrypt detekcji (detector.py)

from ultralytics import YOLO
import cv2, time, requests, os
from datetime import datetime

MODEL     = YOLO("yolov8n.pt")           # nano – najszybszy
RTSP_URL  = "rtsp://admin:haslo@192.168.1.100:554/stream1"
TELEGRAM_TOKEN = os.getenv("TG_TOKEN", "")
TELEGRAM_CHAT  = os.getenv("TG_CHAT",  "")
SNOOZE_SEC     = 30                       # pauza między powiadomieniami

cap          = cv2.VideoCapture(RTSP_URL)
last_alert   = 0
CLASSES_WATCHED = {"person", "car", "dog"}

def wyslij_telegram(img_path: str, etykiety: list):
    if not TELEGRAM_TOKEN:
        return
    tekst = "🚨 Wykryto: " + ", ".join(etykiety)
    with open(img_path, "rb") as f:
        requests.post(
            f"https://api.telegram.org/bot{TELEGRAM_TOKEN}/sendPhoto",
            data={"chat_id": TELEGRAM_CHAT, "caption": tekst},
            files={"photo": f},
            timeout=10
        )

print("Kamera AI uruchomiona…")
while True:
    ret, frame = cap.read()
    if not ret:
        cap = cv2.VideoCapture(RTSP_URL)
        time.sleep(1)
        continue

    wyniki = MODEL(frame, conf=0.45, verbose=False)[0]
    etykiety = [MODEL.names[int(b.cls)] for b in wyniki.boxes
                if MODEL.names[int(b.cls)] in CLASSES_WATCHED]

    if etykiety and (time.time() - last_alert > SNOOZE_SEC):
        ts      = datetime.now().strftime("%Y%m%d_%H%M%S")
        sciezka = f"/tmp/alert_{ts}.jpg"
        cv2.imwrite(sciezka, wyniki.plot())
        wyslij_telegram(sciezka, list(set(etykiety)))
        last_alert = time.time()
        print(f"Alert: {etykiety}")

    time.sleep(0.2)

# Autostart przy starcie systemu
crontab -e
# Dodaj linię:
@reboot source /home/pi/ai-kamera/bin/activate && python /home/pi/detector.py &

Porównanie obu podejść

Bezpieczeństwo sieci

Koszty vs. abonament chmury

Przy 2 latach użytkowania, system lokalny jest tańszy nawet uwzględniając koszt prądu (Pi 4 = ok. 5W = ~2 zł/miesiąc).