webcam

Raspberry-Pi-Anwendung zur Anbindung einer Netzwerk-Webcam per RTSP. Das Programm stellt das aktuelle Kamerabild über eine Weboberfläche bereit, zeichnet Videos in einzelnen Zeitabschnitten auf und erzeugt aus gespeicherten Zeitrafferbildern Zeitrafferfilme.

Funktionen

• Empfang des Kamerastreams über RTSP
• aktuelles Kamerabild für die Weboberfläche
• separates Bild für die Anzeige über das FRITZ!Fon
• fortlaufende Videoaufnahmen
• frei konfigurierbare Dauer der einzelnen Videoaufnahmen
• regelmäßige Zeitraffer-Snapshots
• Erstellung eines Zeitrafferfilms aus den Bildern des aktuellen Tages
• Weboberfläche zur Anzeige und Verwaltung der Aufzeichnungen
• Download und Löschen vorhandener Videoaufnahmen
• Stoppen und Starten der Videoaufnahme über die Weboberfläche
• erneutes Einlesen der config.json während des laufenden Betriebs
• automatische Aufbewahrung und Bereinigung nach den konfigurierten Zeiträumen

Voraussetzungen

Die Anwendung ist für den Betrieb auf einem Raspberry Pi vorgesehen.

Benötigt werden:

• Raspberry Pi mit Linux
• Netzwerkzugriff auf die RTSP-Kamera
• ffmpeg
• eine passende Go-Buildumgebung für die Erstellung des Binaries

Das erzeugte ARM64-Binary wird über die Forgejo-CI erstellt und als Release bereitgestellt.

Projektstruktur

webcam/
├── config.json
├── docker-compose.yaml
├── go.mod
├── internal/
│   └── version/
│       └── version.go
├── LICENSE
├── main.go
├── README.md
├── stoerung.jpg
└── webcam.service

Konfiguration

Die Anwendung verwendet eine JSON-Konfigurationsdatei config.json.

Ein Beispiel:

{
    "rtsp_url": "rtsp://BENUTZER:PASSWORT@192.168.1.100:554/Streaming/Channels/101",
    "base_dir": "./data/kamera",
    "web_server_path": "./data/kamera/aktuell.jpg",
    "video_duration_sec": 1800,
    "snapshot_interval_min": 1,
    "keep_videos_days": 7,
    "keep_snapshots_days": 30,
    "web_listen_addr": ":8083",
    "web_listen_addr_local": ":8084",
    "web_user": "admin",
    "web_password": "admin",
    "timelapse_image_duration_sec": 5
}

Parameter

Parameter	Beschreibung
rtsp_url	RTSP-Adresse der Netzwerk-Webcam. Die URL kann Benutzername und Passwort enthalten.
base_dir	Basisverzeichnis für die erzeugten Bilder und Videos.
web_server_path	Pfad zum aktuellen Kamerabild, das von der Weboberfläche verwendet wird.
video_duration_sec	Dauer einer einzelnen Videoaufnahme in Sekunden. Beispiel: 600 = 10 Minuten, 1800 = 30 Minuten.
snapshot_interval_min	Abstand zwischen den Zeitraffer-Snapshots in Minuten.
keep_videos_days	Anzahl der Tage, für die Videoaufnahmen aufbewahrt werden.
keep_snapshots_days	Anzahl der Tage, für die Zeitraffer-Snapshots aufbewahrt werden.
web_listen_addr	Adresse und Port des normalen Webservers, z. B. :8083.
web_listen_addr_local	Adresse und Port des separaten lokalen Servers für das FRITZ!Fon-Bild, z. B. :8084.
web_user	Benutzername für die Weboberfläche.
web_password	Passwort für die Weboberfläche.
timelapse_image_duration_sec	Anzeigedauer eines einzelnen Bildes im erzeugten Zeitrafferfilm in Sekunden.
timelapse_start_hour	Stunde des täglichen Zeitpunkts für die automatische Zeitraffererstellung (0–23).
timelapse_start_minute	Minute des täglichen Zeitpunkts für die automatische Zeitraffererstellung (0–59).

Sicherheit

Die config.json kann sensible Daten enthalten, insbesondere die Zugangsdaten der RTSP-Kamera.

Die lokale config.json wird deshalb nicht als Release-Asset veröffentlicht.

Für eine Veröffentlichung des Git-Repositories sollte darauf geachtet werden, dass keine echten Kamera-Zugangsdaten committed werden.

Videoaufnahmen

Die Anwendung erzeugt fortlaufend einzelne MP4-Dateien.

Die Länge einer Aufnahme wird mit video_duration_sec festgelegt.

Beispiele:

600 Sekunden  = 10 Minuten
1800 Sekunden = 30 Minuten
3600 Sekunden = 60 Minuten

Kürzere Aufnahmen sind ausdrücklich möglich und können sinnvoll sein, da dadurch kleinere einzelne MP4-Dateien entstehen.

Die erzeugten Dateien werden im konfigurierten Datenverzeichnis gespeichert.

Zeitraffer

Während des Betriebs werden in dem mit snapshot_interval_min festgelegten Abstand Bilder aufgenommen.

Mit der Funktion „Zeitraffer erstellen“ in der Weboberfläche wird aus den Zeitrafferbildern des aktuellen Tages ein Zeitrafferfilm erzeugt.

Die Dauer, mit der ein einzelnes Bild im Zeitrafferfilm angezeigt wird, wird mit timelapse_image_duration_sec festgelegt.

Die erzeugten Zeitrafferfilme werden anschließend wie die normalen Videoaufnahmen in der Weboberfläche angezeigt.

Die automatische tägliche Erstellung erfolgt zu der in timelapse_start_hour und timelapse_start_minute konfigurierten Uhrzeit. Standardmäßig ist dies 03:05 Uhr.

Weboberfläche

Die Weboberfläche ist standardmäßig unter Port 8083 erreichbar.

Die Startseite zeigt:

• das aktuelle Kamerabild
• die aktuelle Uhrzeit
• den Aufnahmestatus
• die verfügbaren Aufzeichnungen
• die Bedienelemente zur Steuerung

Status

Der Status zeigt an, ob Daten von der Webcam empfangen werden.

AUFNAHME AKTIV bedeutet, dass die Aufnahme aktiv ist.

Video Stop / Start

Mit „Video Stop“ wird die laufende Videoaufnahme bzw. Übertragung beendet.

Mit „Video Start“ kann die Aufnahme wieder gestartet werden.

Zeitraffer erstellen

„Zeitraffer erstellen“ erstellt aus den Zeitrafferbildern des heutigen Tages einen Zeitrafferfilm.

Config neu laden

Mit „Config neu laden“ wird die config.json während des laufenden Betriebs erneut eingelesen.

Damit können Änderungen an der Konfiguration übernommen werden, ohne den Dienst vollständig neu zu starten.

Aufzeichnungen

Unterhalb des Kamerabildes werden die vorhandenen Aufzeichnungen angezeigt.

Die Liste enthält Zeitrafferfilme und die einzelnen Videoaufnahmen.

Für jede Datei stehen folgende Aktionen zur Verfügung:

• Download – Datei herunterladen
• Löschen – Datei löschen

Zusätzlich werden Dateiname und Dateigröße angezeigt.

Installation auf dem Raspberry Pi

1. Release herunterladen

Das Release enthält die für die Installation benötigten Dateien:

• webcam-arm64
• webcam-amd64
• stoerung.jpg
• webcam.service

Für einen Raspberry Pi mit ARM64-Betriebssystem wird webcam-arm64 verwendet.

Die Datei config.json ist kein Bestandteil des Releases und muss lokal auf dem Raspberry Pi erstellt bzw. angepasst werden.

2. Installationsverzeichnis vorbereiten

Das Binary und die Konfiguration werden entsprechend der vorhandenen Service-Datei installiert.

sudo mkdir -p /etc/webcam-service
sudo mkdir -p /etc/webcam-service/data

3. Binary installieren

Das ARM64-Binary aus dem Release wird als /usr/local/bin/webcam-service installiert:

sudo cp webcam-arm64 /usr/local/bin/webcam-service
sudo chmod +x /usr/local/bin/webcam-service

4. Konfiguration installieren

Die lokal erstellte config.json wird nach /etc/webcam-service/config.json kopiert:

sudo cp config.json /etc/webcam-service/config.json

Die RTSP-URL und die übrigen Parameter müssen an die lokale Umgebung angepasst werden.

5. Störungsbild installieren

Das Release enthält stoerung.jpg.

sudo cp stoerung.jpg /etc/webcam-service/stoerung.jpg

6. Service-Datei installieren

Die mit dem Release ausgelieferte webcam.service wird nach /etc/systemd/system kopiert:

sudo cp webcam.service /etc/systemd/system/webcam.service

Danach systemd neu laden:

sudo systemctl daemon-reload

7. Dienst aktivieren

Damit der Dienst beim Systemstart automatisch gestartet wird:

sudo systemctl enable webcam.service

8. Dienst starten

sudo systemctl start webcam.service

Status prüfen:

sudo systemctl status webcam.service

webcam.service

Die mitgelieferte Service-Datei verwendet:

[Unit]
Description=Go Webcam Management Service
After=network.target mnt-data.mount

[Service]
Type=simple
User=pi
Group=pi
WorkingDirectory=/etc/webcam-service
ExecStart=/usr/local/bin/webcam-service
Restart=always
RestartSec=10
KillMode=process
SendSIGKILL=no

[Install]
WantedBy=multi-user.target

Der Dienst wird als Benutzer pi ausgeführt.

Das Arbeitsverzeichnis ist:

/etc/webcam-service

Das Programm wird aus:

/usr/local/bin/webcam-service

gestartet.

Betrieb und Logs

Den aktuellen Status des Dienstes anzeigen:

sudo systemctl status webcam.service

Die laufenden Meldungen anzeigen:

sudo journalctl -u webcam.service -f

Die letzten Meldungen anzeigen:

sudo journalctl -u webcam.service -n 100

Dienst neu starten:

sudo systemctl restart webcam.service

Dienst stoppen:

sudo systemctl stop webcam.service

Docker

Für den Betrieb in Docker steht docker-compose.yaml zur Verfügung.

Die Container-Konfiguration stellt den Webserver auf Port 8083 bereit und bindet den Kamera-Datenbereich ein.

Bei Änderungen an der Konfiguration muss darauf geachtet werden, dass die im Container verwendeten Pfade mit den Pfaden aus config.json übereinstimmen.

Verzeichnis bereitstellen

mkdir -p ../srv_webcam/app/data/kamera/video cd ../srv_webcam

Aktuelle Version herunterladen - hier als Beispiel die development-Version

wget https://git.lang-dieter.de/dieter/webcam/releases/download/development/webcam-development.zip

ZIP-Datei entpacken

unzip webcam-development.zip cd webcam-development

Dateien aus ZIP-Archiv verteilen

mv docker* .. mv * ../app

Unzip-Ordner wieder entfernen

cd .. rm webcam-development -rf tree .

Für Testumgebung benötigte Konfiguration einrichten

Kamera-URL setzen

geany app/config.json

Entrypoint auf ./webcam-amd64 für PC

geany dockerfile

Volumens prüfen

- ./app/data/kamera:/app/data für Betrieb auf PC geany docker-compose.yaml cat dockerfile cat docker-compose.yaml ls -la ls -la app

Container erzeugen

docker compose build --no-cache

Seite im Firefox aufrufen

firefox http://localhost:8083

Container starten

docker compose up -d docker logs

Container beenden

docker compose down cd ~/webcam

Versionsinformationen

Die Version wird nicht mehr aus einer lokalen Build-Datei übernommen.

Bei einem Forgejo-Release wird die Versionsnummer aus dem Git-Tag ermittelt.

Beispiel:

v0.9.1

wird im Programm als:

0.9.1

verwendet.

Zusätzlich werden beim CI-Build der kurze Git-Commit und das Build-Datum in das Binary eingebettet.

Diese Informationen werden beim Start des Webcam-Dienstes ausgegeben und in der Weboberfläche für die Versionsinformation verwendet.

Forgejo CI/CD

Der Build wird über den Forgejo-Workflow in .forgejo/workflows/ci.yml durchgeführt.

Der Workflow:

1. Projektinformationen aus Forgejo ermitteln
2. Repository auschecken
3. Go-Code prüfen
4. Go-Tests ausführen
5. Module prüfen
6. Webcam für Linux amd64 bauen
7. Webcam für Linux arm64 bauen
8. Erzeugte Build-Dateien anzeigen
9. Forgejo Development Release löschen 10 Forgejo Development Release erstellen, wenn kein neuer Versionstag vergeben wurde 11 Forgejo Release erstellen, wenn in neuer Versionstag vergeben wurde

Ein normaler Push auf main führt den Build und die Tests aus, erstellt aber nur das Development Release

Ein Git-Tag nach dem Schema

v0.9.1

löst die automatische Release-Erstellung aus. Dabei wird das Development Release gelöscht

Release-Dateien

Ein Release enthält:

config.json.example
docker-compose.yaml
dockerfile
stoerung.jpg
webcam-amd64
webcam-arm64
webcam.service
webcam-v[Versionstag].zip

Die lokale config.json wird nicht veröffentlicht.

Lizenz

Dieses Projekt steht unter der Lizenz GNU General Public License Version 3 oder später (GPL-3.0-or-later).

Siehe LICENSE.