awebsite/content/project/2024-01-30-airaspi-build-log/index.de.md

+++
title = "AIRASPI Build-Protokoll"
authors = ["Aron Petau"]
description = "Nutzung einer Edge-TPU zum Bau eines Edge-Geräts für Bilderkennung und Objektdetektion"
date = 2024-01-30
[taxonomies]
tags = [
  "coral",
  "docker",
  "edge TPU",
  "edge computing",
  "frigate",
  "local AI",
  "private",
  "raspberry pi",
  "surveillance"
]
[extra]
show_copyright = true
show_shares = true
+++

## AI-Raspi Build-Protokoll

Dieses Dokument dokumentiert den Prozess des Baus eines maßgeschneiderten Edge-Computing-Geräts für Echtzeit-Bilderkennung und Objektdetektion. Das Ziel war es, ein portables, eigenständiges System zu schaffen, das unabhängig von Cloud-Infrastruktur funktionieren kann.

**Projektziele:**

Bau eines Edge-Geräts mit Bilderkennung und Objektdetektion, das Video in Echtzeit verarbeiten kann, mit dem Ziel von 30fps bei 720p-Auflösung. Portabilität und autonomer Betrieb sind kritische Anforderungen—das Gerät muss ohne aktive Internetverbindung funktionieren und einen kompakten Formfaktor für Installationsumgebungen beibehalten. Alle Berechnungen finden lokal auf dem Gerät selbst statt, was es zu einer echten Edge-Computing-Lösung ohne Cloud-Abhängigkeit macht.

Dieses Projekt wurde inspiriert von [pose2art](https://github.com/MauiJerry/Pose2Art), das das kreative Potenzial der Echtzeit-Posenerkennung für interaktive Installationen demonstrierte.

## Hardware

- [Raspberry Pi 5](https://www.raspberrypi.com/products/raspberry-pi-5/)
- [Raspberry Pi Camera Module v1.3](https://www.raspberrypi.com/documentation/accessories/camera.html)
- [Raspberry Pi GlobalShutter Camera](https://www.raspberrypi.com/documentation/accessories/camera.html)
- 2x CSI FPC Kabel (benötigt eine kompakte Seite, um in Pi 5 zu passen)
- [Pineberry AI Hat (m.2 E key)](https://pineberrypi.com/products/hat-ai-for-raspberry-pi-5)
- [Coral Dual Edge TPU (m.2 E key)](https://www.coral.ai/products/m2-accelerator-dual-edgetpu)
- Raspi Official 5A Netzteil
- Raspi aktiver Kühler

## Setup

### Hauptressourcen

Dieser Build wäre ohne die exzellente Dokumentation und Troubleshooting-Anleitungen aus der Community nicht möglich gewesen. Die Hauptquellen, auf die ich mich während dieses Projekts verlassen habe, waren:

- [coral.ai offizielle Dokumentation](https://www.coral.ai/docs/m2/get-started/#requirements) - Googles offizieller Setup-Leitfaden für die M.2 Edge TPU
- [Jeff Geerlings Blog](https://www.jeffgeerling.com/blog/2023/pcie-coral-tpu-finally-works-on-raspberry-pi-5) - Kritische PCIe-Konfigurationseinblicke für Raspberry Pi 5
- [Frigate NVR Dokumentation](https://docs.frigate.video) - Umfassender Leitfaden für die Network-Video-Recorder-Software

### Raspberry Pi OS Installation

Ich habe den Raspberry Pi Imager verwendet, um das neueste Raspberry Pi OS auf eine SD-Karte zu flashen. Die OS-Wahl ist kritisch für die Kamerakompatibilität.

> [!IMPORTANT]
> Muss Debian Bookworm sein.
> Muss das vollständige arm64-Image (mit Desktop) sein, sonst gerät man in die
> Kameratreiber-Hölle.

**Initiale Konfigurationseinstellungen:**

Mit den erweiterten Einstellungen des Raspberry Pi Imager habe ich vor dem Flashen Folgendes konfiguriert:

- Verwendung des Standard-arm64-Images (mit Desktop) - kritisch für Kameratreiber-Kompatibilität
- Aktivierung benutzerdefinierter Einstellungen für Headless-Betrieb
- Aktivierung von SSH für Fernzugriff
- Konfiguration des WiFi-Ländercodes für rechtliche Compliance
- Festlegung von WiFi-SSID und Passwort für automatische Netzwerkverbindung
- Konfiguration der Locale-Einstellungen für richtige Zeitzone und Tastaturlayout
- Festlegung eines benutzerdefinierten Hostnamens: `airaspi` für einfache Netzwerkidentifikation

### System-Update

Nach dem ersten Boot ist das Aktualisieren des Systems unerlässlich. Dieser Prozess kann mit dem vollständigen Desktop-Image beträchtliche Zeit in Anspruch nehmen, stellt aber sicher, dass alle Pakete aktuell sind und Sicherheitspatches angewendet werden.

```zsh
sudo apt update && sudo apt upgrade -y && sudo reboot
```

### Vorbereitung des Systems für Coral TPU

Die PCIe-Schnittstelle des Raspberry Pi 5 erfordert eine spezifische Konfiguration, um mit der Coral Edge TPU zu funktionieren. Dieser Abschnitt war technisch am anspruchsvollsten und umfasste Kernel-Modifikationen und Device-Tree-Änderungen. Ein großes Dankeschön an Jeff Geerling für die Dokumentation dieses Prozesses—ohne sein detailliertes Troubleshooting wäre dies nahezu unmöglich gewesen.

```zsh
# Kernel-Version prüfen
uname -a
```

```zsh
# config.txt modifizieren
sudo nano /boot/firmware/config.txt
```

Während man in der Datei ist, folgende Zeilen hinzufügen:

```config
kernel=kernel8.img
dtparam=pciex1
dtparam=pciex1_gen=2
```

Speichern und neu starten:

```zsh
sudo reboot
```

```zsh
# Kernel-Version erneut prüfen
uname -a
```

- sollte jetzt anders sein, mit einem -v8 am Ende

/boot/firmware/cmdline.txt bearbeiten

```zsh
sudo nano /boot/firmware/cmdline.txt
```

- pcie_aspm=off vor rootwait hinzufügen

```zsh
sudo reboot
```

### Modifizierung des Device Tree

#### Initialer Script-Versuch (Veraltet)

Anfangs gab es ein automatisiertes Script, das die Device-Tree-Modifikationen handhaben sollte. Jedoch erwies sich dieses Script als problematisch und verursachte Probleme während meines Builds.

> [!WARNING]
> vielleicht ist dieses Script das Problem?
> ich werde es ohne erneut versuchen

```zsh
curl https://gist.githubusercontent.com/dataslayermedia/714ec5a9601249d9ee754919dea49c7e/raw/32d21f73bd1ebb33854c2b059e94abe7767c3d7e/coral-ai-pcie-edge-tpu-raspberrypi-5-setup | sh
```

Ja, es war das problematische Script. Ich habe einen Kommentar dokumentiert, der das Problem auf dem ursprünglichen Gist beschreibt:
[Mein Kommentar auf dem Gist](https://gist.github.com/dataslayermedia/714ec5a9601249d9ee754919dea49c7e?permalink_comment_id=4860232#gistcomment-4860232)

#### Manuelle Device-Tree-Modifikation (Empfohlen)

Anstatt mich auf das automatisierte Script zu verlassen, folgte ich Jeff Geerlings manuellem Ansatz. Diese Methode gibt vollständige Kontrolle über den Prozess und hilft zu verstehen, was tatsächlich unter der Haube passiert.

> [!NOTE]
> In der Zwischenzeit wurde das Script aktualisiert und wird nun wieder empfohlen.

Der Device-Tree-Modifikationsprozess umfasst das Sichern des aktuellen Device-Tree-Blobs (DTB), das Dekompilieren in ein lesbares Format, das Bearbeiten der MSI-Parent-Referenz zur Behebung von PCIe-Kompatibilitätsproblemen und dann das Zurückkompilieren in Binärformat. Hier ist der schrittweise Prozess:

**1. Device Tree sichern und dekompilieren**

```zsh
# Aktuelles dtb sichern
sudo cp /boot/firmware/bcm2712-rpi-5-b.dtb /boot/firmware/bcm2712-rpi-5-b.dtb.bak

# Aktuelles dtb dekompilieren (Warnungen ignorieren)
dtc -I dtb -O dts /boot/firmware/bcm2712-rpi-5-b.dtb -o ~/test.dts

# Datei bearbeiten
nano ~/test.dts

# Zeile ändern: msi-parent = <0x2f>; (unter `pcie@110000`)
# Zu: msi-parent = <0x66>;
# Dann Datei speichern.

# dtb rekompilieren und zurück ins Firmware-Verzeichnis verschieben
dtc -I dts -O dtb ~/test.dts -o ~/test.dtb
sudo mv ~/test.dtb /boot/firmware/bcm2712-rpi-5-b.dtb

# Neustart für Änderungen
sudo reboot
```

> [!NOTE]
> Hinweis: msi-parent scheint heutzutage den Wert <0x2c> zu haben, hat mich ein paar Stunden gekostet.

**2. Änderungen verifizieren**

Nach dem Neustart prüfen, dass die Coral TPU vom System erkannt wird:

```zsh
lspci -nn | grep 089a
```

Die Ausgabe sollte ähnlich sein: `0000:01:00.0 System peripheral [0880]: Global Unichip Corp. Coral Edge TPU [1ac1:089a]`

### Installation des Apex-Treibers

Mit dem ordnungsgemäß konfigurierten Device Tree ist der nächste Schritt die Installation von Googles Apex-Treiber für die Coral Edge TPU. Dieser Treiber ermöglicht die Kommunikation zwischen Betriebssystem und TPU-Hardware.

Gemäß den offiziellen Anweisungen von [coral.ai](https://coral.ai/docs/m2/get-started#2a-on-linux):

```zsh
echo "deb https://packages.cloud.google.com/apt coral-edgetpu-stable main" | sudo tee /etc/apt/sources.list.d/coral-edgetpu.list

curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -

sudo apt-get update

sudo apt-get install gasket-dkms libedgetpu1-std

sudo sh -c "echo 'SUBSYSTEM==\"apex\", MODE=\"0660\", GROUP=\"apex\"' >> /etc/udev/rules.d/65-apex.rules"

sudo groupadd apex

sudo adduser $USER apex

sudo reboot
```

Diese Sequenz:

1. Fügt Googles Paket-Repository und GPG-Schlüssel hinzu
2. Installiert das gasket DKMS-Modul (Kernel-Treiber) und Edge-TPU-Runtime-Bibliothek
3. Erstellt udev-Regeln für Geräteberechtigungen
4. Erstellt eine `apex`-Gruppe und fügt den Benutzer hinzu
5. Neustart zum Laden des Treibers

Nach dem Neustart Installation verifizieren:

```zsh
lspci -nn | grep 089a
```

Dies sollte die verbundene Coral TPU als PCIe-Gerät anzeigen.

Als Nächstes bestätigen, dass der Device-Node mit entsprechenden Berechtigungen existiert:

```zsh
ls -l /dev/apex_0
```

Wenn die Ausgabe `/dev/apex_0` mit entsprechenden Gruppenberechtigungen zeigt, war die Installation erfolgreich. Falls nicht, udev-Regeln und Gruppenzugehörigkeit überprüfen.

### Testen mit Beispielmodellen

Um zu verifizieren, dass die TPU korrekt funktioniert, verwenden wir Googles Beispiel-Klassifizierungsskript mit einem vortrainierten MobileNet-Modell:

```zsh
# Python-Pakete installieren
sudo apt-get install python3-pycoral

# Beispiel-Code und Modelle herunterladen
mkdir -p ~/coral && cd ~/coral
git clone https://github.com/google-coral/pycoral.git
cd pycoral

# Vogel-Klassifizierungsbeispiel ausführen
python3 examples/classify_image.py \
  --model test_data/mobilenet_v2_1.0_224_inat_bird_quant_edgetpu.tflite \
  --labels test_data/inat_bird_labels.txt \
  --input test_data/parrot.jpg
```

Die Ausgabe sollte Inferenz-Ergebnisse mit Konfidenzwerten zeigen, was bestätigt, dass die Edge TPU korrekt funktioniert.

### Docker-Installation

Docker bietet Containerisierung für die Anwendungen, die wir ausführen werden (Frigate, MediaMTX, etc.). Dies hält Abhängigkeiten isoliert und macht das Deployment wesentlich sauberer.

Docker mit dem offiziellen Convenience-Script von [docker.com](https://docs.docker.com/engine/install/debian/#install-using-the-convenience-script) installieren:

```zsh
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh
sudo usermod -aG docker $USER
```

Nach der Installation ab- und wieder anmelden, damit Änderungen der Gruppenzugehörigkeit wirksam werden.

Docker so konfigurieren, dass es automatisch beim Booten startet:

```zsh
sudo systemctl enable docker.service
sudo systemctl enable containerd.service
```

### Edge TPU testen (Optional)

Um zu verifizieren, dass die Edge TPU innerhalb eines Docker-Containers funktioniert, können wir ein Test-Image bauen. Dies ist besonders nützlich, wenn man plant, die TPU mit containerisierten Anwendungen zu nutzen.

Test-Verzeichnis und Dockerfile erstellen:

```zsh
mkdir coraltest
cd coraltest
sudo nano Dockerfile
```

In die neue Datei einfügen:

```Dockerfile
FROM debian:10

WORKDIR /home
ENV HOME /home
RUN cd ~
RUN apt-get update
RUN apt-get install -y git nano python3-pip python-dev pkg-config wget usbutils curl

RUN echo "deb https://packages.cloud.google.com/apt coral-edgetpu-stable main" \
| tee /etc/apt/sources.list.d/coral-edgetpu.list
RUN curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | apt-key add -
RUN apt-get update
RUN apt-get install -y edgetpu-examples
RUN apt-get install libedgetpu1-std
CMD /bin/bash
```

Test-Container bauen und ausführen, Coral-Gerät durchreichen:

```zsh
# Docker-Container bauen
docker build -t "coral" .

# Docker-Container ausführen
docker run -it --device /dev/apex_0:/dev/apex_0 coral /bin/bash
```

Innerhalb des Containers ein Inferenz-Beispiel ausführen:

```zsh
# Inferenz-Beispiel innerhalb des Containers ausführen
python3 /usr/share/edgetpu/examples/classify_image.py --model /usr/share/edgetpu/examples/models/mobilenet_v2_1.0_224_inat_bird_quant_edgetpu.tflite --label /usr/share/edgetpu/examples/models/inat_bird_labels.txt --image /usr/share/edgetpu/examples/images/bird.bmp
```

Man sollte Inferenz-Ergebnisse mit Konfidenzwerten von der Edge TPU sehen. Falls nicht, einen sauberen Neustart des Systems versuchen.

### Portainer (Optional)

Portainer bietet eine webbasierte GUI für die Verwaltung von Docker-Containern, Images und Volumes. Obwohl nicht erforderlich, macht es das Container-Management deutlich komfortabler.

> [!NOTE]
> Dies ist optional, gibt einem eine Browser-GUI für die verschiedenen Docker-Container.

Portainer installieren:

```zsh
docker volume create portainer_data
docker run -d -p 8000:8000 -p 9443:9443 --name portainer --restart=always -v /var/run/docker.sock:/var/run/docker.sock -v portainer_data:/data portainer/portainer-ce:latest
```

Portainer im Browser aufrufen und Admin-Passwort setzen:

- Navigieren zu: <https://airaspi.local:9443>

### VNC-Setup (Optional)

VNC bietet Remote-Desktop-Zugriff auf den Headless-Raspberry Pi. Dies ist besonders nützlich zum Testen von Kameras und Debuggen von visuellen Problemen, ohne einen physischen Monitor anzuschließen.

> [!NOTE]
> Dies ist optional, nützlich zum Testen der Kameras auf dem Headless-Gerät. Man könnte
> einen Monitor anschließen, aber ich finde VNC bequemer.

VNC über das Raspberry Pi Konfigurationstool aktivieren:

```zsh
sudo raspi-config
```

Navigieren zu: **Interface Options** → **VNC** → **Enable**

### Verbindung über VNC Viewer

[RealVNC Viewer](https://www.realvnc.com/en/connect/download/viewer/) auf dem Computer installieren (verfügbar für macOS, Windows und Linux).

Mit der Adresse verbinden: `airaspi.local:5900`

Man wird nach Benutzernamen und Passwort des Raspberry Pi gefragt. Nach der Verbindung hat man vollen Remote-Desktop-Zugriff zum Testen von Kameras und Debuggen.

## Frigate NVR Setup

Frigate ist ein vollständiger Network Video Recorder (NVR) mit Echtzeit-Objektdetektion, angetrieben von der Coral Edge TPU. Es ist das Herzstück dieses Edge-AI-Systems.

### Docker Compose Konfiguration

Dieses Setup verwendet Docker Compose, um den Frigate-Container mit allen notwendigen Konfigurationen zu definieren. Wenn man Portainer verwendet, kann man dies als Custom Stack hinzufügen.

> [!IMPORTANT]
> Wichtig: Die Pfade müssen auf die eigenen Pfade angepasst werden.

```yaml
version: "3.9"
services:
  frigate:
    container_name: frigate
    privileged: true # dies ist möglicherweise nicht für alle Setups notwendig
    restart: unless-stopped
    image: ghcr.io/blakeblackshear/frigate:stable
    shm_size: "64mb" # für Kameras basierend auf obiger Berechnung aktualisieren
    devices:
      - /dev/apex_0:/dev/apex_0 # reicht PCIe Coral durch, Treiberanweisungen hier folgen https://coral.ai/docs/m2/get-started/#2a-on-linux

    volumes:
      - /etc/localtime:/etc/localtime:ro
      - /home/aron/frigate/config.yml:/config/config.yml # durch eigene Config-Datei ersetzen
      - /home/aron/frigate/storage:/media/frigate # durch eigenes Storage-Verzeichnis ersetzen
      - type: tmpfs # Optional: 1GB Speicher, reduziert SSD/SD-Karten-Verschleiß
        target: /tmp/cache
        tmpfs:
          size: 1000000000
    ports:
      - "5000:5000"
      - "8554:8554" # RTSP feeds
      - "8555:8555/tcp" # WebRTC über tcp
      - "8555:8555/udp" # WebRTC über udp
    environment:
      FRIGATE_RTSP_PASSWORD: "******"
```

Wichtige Konfigurationspunkte in dieser Docker-Compose-Datei:

- **Privileged-Modus** und **Device-Mappings**: Erforderlich für Hardwarezugriff (TPU, Kameras)
- **Shared Memory Size**: Zugewiesen für effiziente Video-Frame-Verarbeitung
- **Port-Mappings**: Macht Frigate's Web-UI (5000) und RTSP-Streams (8554) zugänglich
- **Volume-Mounts**: Persistiert Aufnahmen, Konfiguration und Datenbank

### Frigate-Konfigurationsdatei

Frigate benötigt eine YAML-Konfigurationsdatei, um Kameras, Detektoren und Detektionszonen zu definieren. Diese Datei am Pfad erstellen, der in der docker-compose-Datei angegeben wurde (z.B. `/home/aron/frigate/config.yml`).

> [!NOTE]
> Dies ist nur einmal notwendig. Danach kann man die Konfiguration in der GUI ändern.

Hier ist eine funktionierende Konfiguration mit der Coral TPU:

```yaml
mqtt:
  enabled: False

detectors:
  cpu1:
    type: cpu
    num_threads: 3
  coral_pci:
    type: edgetpu
    device: pci

cameras:
  cam1: # <++++++ Kamera benennen
    ffmpeg:
      hwaccel_args: preset-rpi-64-h264
      inputs:
        - path: rtsp://192.168.1.58:8900/cam1
          roles:
            - detect
  cam2: # <++++++ Kamera benennen
    ffmpeg:
      hwaccel_args: preset-rpi-64-h264
      inputs:
        - path: rtsp://192.168.1.58:8900/cam2
          roles:
            - detect
    detect:
      enabled: True # <+++- Detektion deaktivieren bis funktionierende Kamera-Feeds vorhanden
      width: 1280 # <+++- für Kameraauflösung aktualisieren
      height: 720 # <+++- für Kameraauflösung aktualisieren
```

Diese Konfiguration:

- **Deaktiviert MQTT**: Vereinfacht Setup für rein lokalen Betrieb
- **Definiert zwei Detektoren**: Einen Coral-TPU-Detektor (`coral`) und einen CPU-Fallback
- **Verwendet Standard-Detektionsmodell**: Frigate enthält ein vortrainiertes Modell
- **Konfiguriert zwei Kameras**: Beide auf 1280x720-Auflösung eingestellt
- **Verwendet Hardware-Beschleunigung**: `preset-rpi-64-h264` für Raspberry Pi 5
- **Detektionszonen**: Nur aktivieren, wenn Kamera-Feeds ordnungsgemäß funktionieren

## MediaMTX Setup

MediaMTX ist ein Echtzeit-Medienserver, der das Streaming von den Raspberry-Pi-Kameras zu Frigate handhabt. Es ist notwendig, weil Frigate `libcamera` (den modernen Raspberry Pi Kamera-Stack) nicht direkt unterstützt.

MediaMTX direkt auf dem System installieren (nicht via Docker - die Docker-Version hat Kompatibilitätsprobleme mit libcamera).

> [!WARNING]
> Chip-Architektur beim Download doppelt prüfen - dies verursachte mir erhebliche
> Kopfschmerzen beim Setup.

MediaMTX herunterladen und installieren:

```zsh
mkdir mediamtx
cd mediamtx
wget https://github.com/bluenviron/mediamtx/releases/download/v1.5.0/mediamtx_v1.5.0_linux_arm64v8.tar.gz

tar xzvf mediamtx_v1.5.0_linux_arm64v8.tar.gz && rm mediamtx_v1.5.0_linux_arm64v8.tar.gz
```

### MediaMTX-Konfiguration

Die `mediamtx.yml`-Datei bearbeiten, um Kamera-Streams zu konfigurieren. Die untenstehende Konfiguration verwendet `rpicam-vid` (Raspberry Pis modernes Kamera-Tool), das durch FFmpeg geleitet wird, um RTSP-Streams zu erstellen.

Folgendes zum `paths`-Abschnitt in `mediamtx.yml` hinzufügen:

```yaml
paths:
 cam1:
   runOnInit: bash -c 'rpicam-vid -t 0 --camera 0 --nopreview --codec yuv420 --width 1280 --height 720 --inline --listen -o - | ffmpeg -f rawvideo -pix_fmt yuv420p -s:v 1280x720 -i /dev/stdin -c:v libx264 -preset ultrafast -tune zerolatency -f rtsp rtsp://localhost:$RTSP_PORT/$MTX_PATH'
   runOnInitRestart: yes
 cam2:
   runOnInit: bash -c 'rpicam-vid -t 0 --camera 1 --nopreview --codec yuv420 --width 1280 --height 720 --inline --listen -o - | ffmpeg -f rawvideo -pix_fmt yuv420p -s:v 1280x720 -i /dev/stdin -c:v libx264 -preset ultrafast -tune zerolatency -f rtsp rtsp://localhost:$RTSP_PORT/$MTX_PATH'
   runOnInitRestart: yes
```

Diese Konfiguration:

- **`cam1` und `cam2`**: Definieren zwei Kamerapfade
- **`rpicam-vid`**: Erfasst YUV420-Video von Raspberry-Pi-Kameras
- **`ffmpeg`**: Transkodiert das Rohvideo zu H.264-RTSP-Stream
- **`runOnInitRestart: yes`**: Startet Stream automatisch neu, falls er fehlschlägt

### Port-Konfiguration

Standard-RTSP-Port ändern, um Konflikte mit Frigate zu vermeiden:

In `mediamtx.yml` ändern:

```yaml
rtspAddress: :8554
```

Zu:

```yaml
rtspAddress: :8900
```

Sonst gibt es einen Port-Konflikt mit Frigate.

### MediaMTX starten

MediaMTX im Vordergrund ausführen, um zu verifizieren, dass es funktioniert:

```zsh
./mediamtx
```

Wenn keine Fehler auftreten, Streams mit VLC oder einem anderen RTSP-Client verifizieren:

- `rtsp://airaspi.local:8900/cam1`
- `rtsp://airaspi.local:8900/cam2`

Hinweis: Standard-RTSP-Port ist 8554, aber wir haben ihn in der Konfiguration auf 8900 geändert.

## Aktueller Status und Performance

### Was funktioniert

Das System streamt erfolgreich von beiden Kameras mit 30fps und 720p-Auflösung. Die Coral Edge TPU führt Objektdetektion mit minimaler Latenz durch - die TPU selbst kommt nicht ins Schwitzen und behält durchgehend hohe Performance bei.

Laut Frigate-Dokumentation kann die TPU bis zu 10 Kameras handhaben, es gibt also erheblichen Spielraum für Erweiterung.

### Aktuelle Probleme

Es gibt jedoch mehrere signifikante Probleme, die das System behindern:

**1. Frigate Display-Limitierungen**

Frigate begrenzt die Display-FPS auf 5, was deprimierend anzusehen ist, besonders da die TPU nicht einmal ins Schwitzen kommt. Die Hardware ist eindeutig zu viel mehr fähig, aber Software-Limitierungen halten sie zurück.

**2. Stream-Stabilitätsprobleme**

Der Stream ist völlig unberechenbar und droppt ständig Frames. Ich habe manchmal Detektions-FPS von nur 0,2 beobachtet, aber die TPU-Geschwindigkeit sollte definitiv nicht der Flaschenhals sein. Eine mögliche Lösung könnte sein, die Kameras an ein separates Gerät anzuschließen und von dort zu streamen.

**3. Coral-Software-Aufgabe**

Das größte Problem ist, dass Google das Coral-Ökosystem scheinbar aufgegeben hat, obwohl sie gerade neue Hardware dafür veröffentlicht haben. Ihr aktuellster Python-Build unterstützt nur Python 3.9.

Speziell scheint `pycoral` das Problem zu sein - ohne ein ordentliches Update bin ich auf Debian 10 mit Python 3.7.3 beschränkt. Das ist mies. Es gibt Custom-Wheels, aber nichts, das plug-and-play zu sein scheint.

Dies schränkt die Fähigkeit, moderne Software und Bibliotheken mit dem System zu nutzen, erheblich ein.

## Reflexionen und Lessons Learned

### Hardware-Entscheidungen

**Die M.2 E Key-Wahl**

Die Entscheidung, die M.2 E Key-Version zu nehmen, um Geld zu sparen, anstatt mehr für die USB-Version auszugeben, war ein riesiger Fehler. Bitte tu dir selbst einen Gefallen und gib die zusätzlichen 40 Euro aus.

Technisch ist sie wahrscheinlich schneller und besser für Dauerbetrieb, aber ich habe den Vorteil davon noch nicht gespürt. Die USB-Version hätte wesentlich mehr Flexibilität und einfacheres Debugging geboten.

## Zukünftige Entwicklung

Mehrere Verbesserungen und Experimente sind geplant, um dieses System zu erweitern:

**Dokumentation und visuelle Hilfsmittel**

- Bilder und Screenshots zu diesem Build-Protokoll hinzufügen, um es einfacher nachzuvollziehen

**Mobile-Stream-Integration**

- Prüfen, ob [vdo.ninja](https://vdo.ninja) ein praktikabler Weg ist, mobile Streams hinzuzufügen, um Smartphone-Kamera-Integration und -Evaluierung zu ermöglichen

**MediaMTX libcamera-Unterstützung**

- Die MediaMTX-Entwickler*innen bezüglich libcamera-Unterstützung kontaktieren, was den aktuellen `rpicam-vid`-Workaround eliminieren würde. Ich vermute, dass in der aktuellen Pipeline einiges an Performance verloren geht.

**Frigate-Konfigurationsverfeinerung**

- Die Frigate-Konfiguration optimieren, um Snapshots zu aktivieren und möglicherweise eine Bild-/Videodatenbank zum späteren Training benutzerdefinierter Modelle aufzubauen

**Speichererweiterung**

- Sich um das Anbringen einer externen SSD kümmern und die Videodateien darauf für Langzeitspeicherung und -analyse speichern

**Datenexport-Fähigkeiten**

- Einen Weg finden, die Landmarkenpunkte von Frigate zu exportieren, möglicherweise via OSC (wie in meinem [pose2art](/project/pose2art/)-Projekt) für kreative Anwendungen zu senden

**Dual-TPU-Zugriff**

- Einen anderen HAT finden, der Zugriff auf die andere TPU ermöglicht - ich habe die Dual-Version, kann aber aufgrund von Hardware-Einschränkungen derzeit nur auf 1 der 2 TPUs zugreifen