Die KI-Dashcam: Ein technisches und rechtliches Deep Dive

Autor: DerSchneider

Einleitung

Dashcams sind längst Alltag auf deutschen Straßen. Doch die meisten Geräte sind „dumm“ – sie zeichnen auf, ohne zu verstehen, was sie sehen. Was aber, wenn die Kamera nicht nur dokumentiert, sondern auch interpretiert? Wenn sie Fußgänger erkennt, Kollisionen vorhersagt und nur dann speichert, wenn es wirklich relevant wird?

Genau hier setzt ein ambitioniertes Projekt an: der Bau einer intelligenten Dashcam auf Basis zweier Google Coral Dev Boards mit integrierter KI-Bildverarbeitung. Dieses Deep Dive beleuchtet die technischen Möglichkeiten, die rechtlichen Rahmenbedingungen und die vielfältigen Einsatzszenarien eines solchen Systems – von der privaten Unfallbeweissicherung bis hin zum behördlichen Einsatz an neuralgischen Punkten.

Teil 1: Die Hardware – Zwei Boards, zwei Kameras, eine Mission

Das Herzstück: Google Coral Dev Board

Das Google Coral Dev Board ist ein Einplatinencomputer, der speziell für maschinelles Lernen am Edge (Edge AI) konzipiert wurde. Sein Kernstück ist der Edge TPU-Coprozessor, ein ASIC, der mit 4 TOPS (Tera-Operationen pro Sekunde) bei lediglich 2 Watt Leistungsaufnahme arbeitet. Zum Vergleich: Moderne Objekterkennungsmodelle lassen sich auf diesem Board mit über 100 Bildern pro Sekunde ausführen.

Die technischen Spezifikationen im Überblick:

Die Leistungsfähigkeit des Edge TPU ist beeindruckend: Objekterkennungsmodelle laufen in Echtzeit mit über 100 Bildern pro Sekunde, Bildklassifizierungsmodelle sogar mit fast 400 Bildern pro Sekunde.

Die Kamera: MIPI-CSI2 mit einer Einschränkung

Die offizielle Coral Camera ist ein 5-Megapixel-Modul mit Omnivision OV5645-Sensor, Autofokus und einem Sichtfeld von 84 Grad. Angeschlossen wird sie über den MIPI-CSI2-Anschluss des Dev Boards.

Hier zeigt sich die erste hardwaretechnische Hürde: Die Coral Dev Boards erlauben standardmäßig den Anschluss von nur einem Kameramodul. Für das geplante Zwei-Kamera-Setup (vorne und hinten) bedeutet das: Zwei separate Dev Boards sind die einfachste Lösung.

Die Systemarchitektur im Detail

text

┌─────────────────────────┐     ┌─────────────────────────┐
│   Coral Dev Board #1    │     │   Coral Dev Board #2    │
│   (Frontkamera)         │     │   (Heckkamera)          │
│                         │     │                         │
│  ┌───────────────────┐  │     │  ┌───────────────────┐  │
│  │  MIPI-CSI2 Kamera │  │     │  │  MIPI-CSI2 Kamera │  │
│  └───────────────────┘  │     │  └───────────────────┘  │
│  ┌───────────────────┐  │     │  ┌───────────────────┐  │
│  │  Edge TPU         │  │     │  │  Edge TPU         │  │
│  │  (KI-Inferenz)    │  │     │  │  (KI-Inferenz)    │  │
│  └───────────────────┘  │     │  └───────────────────┘  │
│  ┌───────────────────┐  │     │  ┌───────────────────┐  │
│  │  GPS (UART)       │  │     │  │  IMU (I2C)        │  │
│  └───────────────────┘  │     │  └───────────────────┘  │
└───────────┬─────────────┘     └───────────┬─────────────┘
            │                               │
            └───────────────┬───────────────┘
                            │
                            ▼
            ┌───────────────────────────────┐
            │          Mini-PC              │
            │  ┌─────────────────────────┐  │
            │  │  Zentrale Steuerung     │  │
            │  │  - Loop-Recording       │  │
            │  │  - Datenbank (SQLite)   │  │
            │  │  - Web-UI (Flask/Dash)  │  │
            │  └─────────────────────────┘  │
            │  ┌─────────────────────────┐  │
            │  │  Speicher               │  │
            │  │  - SSD/HDD             │  │
            │  │  - NAS-Anbindung       │  │
            │  └─────────────────────────┘  │
            └───────────────────────────────┘

Jedes Dev Board übernimmt folgende Aufgaben:

• Bildaufnahme über die MIPI-CSI2-Kamera
• KI-Inferenz (Objekterkennung, Segmentierung) auf dem Edge TPU
• Telemetrieerfassung (GPS über UART, IMU über I2C)
• Datenübertragung an den Mini-PC (per Ethernet/WLAN)

Der Mini-PC wiederum:

• Empfängt die Videostreams beider Boards
• Speichert die Aufnahmen im Loop-Recording-Modus
• Führt bei Bedarf Nachbearbeitungen durch
• Stellt eine Benutzeroberfläche für Konfiguration und Live-Ansicht bereit

Teil 2: Die Software – Code, Variationen und Implementierungsstrategien

Grundgerüst: Die offiziellen Coral-Beispiele

Google stellt auf der offiziellen Coral-Website verschiedene trainierte Modelle bereit, die für den Edge TPU kompiliert wurden – darunter Modelle für Objekterkennung, Bildklassifizierung und semantische Segmentierung.

Die Objekterkennungsmodelle im Überblick:

Die Wahl des Modells beeinflusst maßgeblich die Performance. Für eine Dashcam, die Echtzeit-Objekterkennung bei 30 fps benötigt, sind die leichteren Modelle (SSD MobileNet V1/V2) besser geeignet.

Die GStreamer-Pipeline

Die leistungsfähigste Implementierung nutzt GStreamer für hardwarebeschleunigte Videoverarbeitung:

python

import gi
gi.require_version('Gst', '1.0')
from gi.repository import Gst, GLib
import numpy as np
import cv2

# GStreamer-Pipeline für Coral-Kamera mit Edge TPU
pipeline_str = """
    v4l2src device=/dev/video0 ! 
    video/x-raw,width=640,height=480,framerate=30/1 ! 
    videoconvert ! 
    video/x-raw,format=RGB ! 
    tee name=t
    t. ! queue ! 
    tensor_filter framework=tensorflow-lite model=ssd_mobilenet_v2_coco_quant_postprocess_edgetpu.tflite ! 
    tensor_transform mode=arithmetic option=typecast:float32,add:-127,div:127 ! 
    tensor_sink name=inference
    t. ! queue ! 
    videoconvert ! 
    autovideosink
"""

# Pipeline initialisieren
Gst.init(None)
pipeline = Gst.parse_launch(pipeline_str)
pipeline.set_state(Gst.State.PLAYING)

Die PyCoral-API für Objekterkennung

Für eine flexiblere Steuerung bietet sich die offizielle pycoral-Bibliothek an. Das Repository bastiankrohg/detection auf GitHub zeigt eine vollständige Implementierung:

python

import cv2
from pycoral.adapters import common, detect
from pycoral.utils import edgetpu
from pycoral.utils.dataset import read_label_file

class CoralObjectDetector:
    def __init__(self, model_path, label_path):
        # Edge TPU-interpreter initialisieren
        self.interpreter = edgetpu.make_interpreter(model_path)
        self.interpreter.allocate_tensors()
        self.labels = read_label_file(label_path)
        
    def detect(self, frame, threshold=0.5):
        # Bild für das Modell vorbereiten
        rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
        common.set_input(self.interpreter, rgb)
        
        # Inferenz ausführen
        self.interpreter.invoke()
        
        # Ergebnisse extrahieren
        objs = detect.get_objects(self.interpreter, threshold)
        return objs
    
    def draw_boxes(self, frame, objs):
        for obj in objs:
            bbox = obj.bbox
            label = self.labels.get(obj.id, obj.id)
            cv2.rectangle(frame, (bbox.xmin, bbox.ymin), 
                          (bbox.xmax, bbox.ymax), (0, 255, 0), 2)
            cv2.putText(frame, f"{label}: {obj.score:.2f}", 
                        (bbox.xmin, bbox.ymin - 10),
                        cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
        return frame

Loop-Recording mit KI-Trigger

Die zentrale Funktion einer Dashcam ist das Loop-Recording mit ereignisbasierter Speicherung:

python

from collections import deque
import time
import threading
import cv2

class DashcamLoop:
    def __init__(self, buffer_seconds=15, fps=30):
        self.buffer_size = buffer_seconds * fps
        self.buffer = deque(maxlen=self.buffer_size)
        self.detector = CoralObjectDetector("model.tflite", "labels.txt")
        self.recording = False
        self.event_triggered = False
        self.lock = threading.Lock()
        
    def process_frame(self, frame):
        # KI-Inferenz durchführen
        objs = self.detector.detect(frame, threshold=0.4)
        
        # Kollisionsgefahr erkennen (z.B. Fußgänger im Nahbereich)
        collision_risk = self.assess_collision_risk(objs)
        
        # Trigger-Bedingungen prüfen
        if collision_risk > 0.7 or self.is_manual_trigger() or self.is_impact_detected():
            self.event_triggered = True
            self.recording = True
            self.save_buffer()
            
        # Buffer aktualisieren (mit Annotationen)
        annotated = self.detector.draw_boxes(frame, objs)
        with self.lock:
            self.buffer.append((annotated, time.time()))
            
        return annotated
    
    def assess_collision_risk(self, objs):
        """Berechnet Kollisionswahrscheinlichkeit basierend auf Objektpositionen"""
        risk = 0.0
        for obj in objs:
            # Je nach Objekttyp und Position im Bild
            if obj.id in [0, 1]:  # Person, Fahrrad
                # Wenn Objekt in der unteren Bildhälfte und zentriert
                if obj.bbox.ymin > 0.6 and 0.3 < obj.bbox.xmin < 0.7:
                    risk = max(risk, 0.8)
        return risk
    
    def save_buffer(self):
        """Speichert den aktuellen Puffer dauerhaft"""
        timestamp = time.strftime("%Y%m%d_%H%M%S")
        filename = f"event_{timestamp}.mp4"
        # Hier: VideoWriter für dauerhafte Speicherung
        # ...

Zwei-Stream-Synchronisation

Bei zwei separaten Dev Boards ist die Synchronisation der Videostreams eine Herausforderung:

python

import time
import cv2

def annotate_frame(frame, board_id, gps_data=None):
    """Fügt Zeitstempel und Telemetrie in das Bild ein"""
    timestamp = time.time_ns()  # Nanosekunden-Genauigkeit
    cv2.putText(frame, f"Board {board_id} - {timestamp}", 
                (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255,255,255), 2)
    
    if gps_data:
        cv2.putText(frame, f"GPS: {gps_data['lat']:.6f}, {gps_data['lon']:.6f}", 
                    (10, 60), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255,255,255), 1)
        cv2.putText(frame, f"Speed: {gps_data['speed']:.1f} km/h", 
                    (10, 80), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255,255,255), 1)
    
    return frame, timestamp

Telemetrie-Einbindung

GPS (über UART):

python

import serial
import pynmea2

class GPSModule:
    def __init__(self, port='/dev/ttyS0', baudrate=9600):
        self.ser = serial.Serial(port, baudrate, timeout=1)
        
    def read(self):
        line = self.ser.readline().decode('ascii', errors='ignore')
        if line.startswith('$GPGGA'):
            try:
                msg = pynmea2.parse(line)
                return {
                    'lat': msg.latitude,
                    'lon': msg.longitude,
                    'altitude': msg.altitude,
                    'timestamp': msg.timestamp
                }
            except:
                return None
        return None

IMU (über I2C):

python

import smbus
import math

class IMUModule:
    def __init__(self, address=0x68):
        self.bus = smbus.SMBus(1)
        self.address = address
        # MPU6050 initialisieren
        self.bus.write_byte_data(address, 0x6B, 0)
        
    def read_accel(self):
        """Liest Beschleunigungsdaten (für Kollisionserkennung)"""
        data = self.bus.read_i2c_block_data(self.address, 0x3B, 6)
        ax = self._combine(data[0], data[1])
        ay = self._combine(data[2], data[3])
        az = self._combine(data[4], data[5])
        return {'x': ax, 'y': ay, 'z': az}
    
    def _combine(self, high, low):
        value = (high << 8) | low
        if value >= 0x8000:
            value = -((65535 - value) + 1)
        return value / 16384.0  # Skalierungsfaktor für ±2g

Frigate-Integration: Die Open-Source-Alternative

Frigate ist ein Open-Source-Network-Video-Recorder (NVR), der lokale KI-Objekterkennung mit NVR-Funktionalität kombiniert. Es erkennt Personen, Autos, Hunde, Katzen und mehr – alles ohne Cloud.

Die Integration des Coral Edge TPU in Frigate ist dokumentiert und ermöglicht die Verarbeitung mehrerer Kameras mit einem einzigen Coral:

yaml

# Frigate Konfiguration für Coral Edge TPU
detectors:
  coral:
    type: edgetpu
    device: usb

cameras:
  front:
    ffmpeg:
      inputs:
        - path: rtsp://192.168.1.100:8554/front
          roles:
            - detect
            - record
    detect:
      width: 640
      height: 480
      fps: 5
    objects:
      track:
        - person
        - car
        - bicycle

Frigate trennt dabei den Detect-Stream (niedrige Auflösung für effiziente KI) vom Record-Stream (hohe Auflösung für dauerhafte Speicherung) – ein Konzept, das auch für die hier beschriebene Dashcam-Architektur sinnvoll ist.

Teil 3: Die rechtliche Dimension – Zwischen Datenschutz und Beweissicherung

Die aktuelle Rechtslage

Die Rechtslage rund um Dashcams in Deutschland ist differenziert. Das dauerhafte und anlasslose Filmen im Straßenverkehr ist unzulässig. Wer permanent aufzeichnet, erfasst automatisch personenbezogene Daten wie Kennzeichen, Gesichter oder Hausfassaden – und das ist datenschutzrechtlich nicht erlaubt.

Die entscheidende Nuance: Der Bundesgerichtshof hat bereits 2018 entschieden, dass anlassloses Dauerfilmen gegen Datenschutzgrundsätze verstößt, aber daraus folgt kein generelles Beweisverwertungsverbot. Ein Gericht darf also Aufnahmen verwenden, selbst wenn sie datenschutzwidrig entstanden sind.

Die zentrale Frage ist, ob die Aufnahme im konkreten Verfahren eingesetzt werden darf. Die Entscheidung liegt beim Richter, der zwischen dem Informationsinteresse an einem funktionierenden Zivilprozess und dem Schutz der Persönlichkeitsrechte abwägen muss.

Die Grauzone des Dauerfilmes

Technisch arbeiten moderne Dashcams mit kurzen Schleifen, die sich fortlaufend überschreiben. Nur bei starken Erschütterungen oder manueller Aktivierung wird eine Sequenz dauerhaft gespeichert. Damit erfüllen viele Geräte das Kriterium der anlassbezogenen Aufnahme.

Dennoch bleibt eine rechtliche Grauzone bestehen, insbesondere wenn Nutzer die Daueraufnahme aktivieren oder wenn Fahrzeuge mit „Wächtermodus“ im öffentlichen Raum kontinuierlich filmen.

Die Veröffentlichung von Dashcam-Videos

Sobald fremde Personen, Fahrzeuge oder Orte erkennbar sind, drohen Abmahnungen und Bußgelder. Das Hochladen solcher Clips ist in der Regel nicht erlaubt, weil dadurch die Persönlichkeitsrechte Dritter verletzt werden.

Wer dennoch ein Dashcam-Video teilen möchte, muss sämtliche identifizierbaren Merkmale unkenntlich machen – Gesichter, Kennzeichen, Hausnummern oder markante Orte. Erst wenn niemand mehr erkennbar ist, kann ein Upload rechtlich unbedenklich sein.

Implikationen für das KI-Dashcam-Projekt

Für das hier beschriebene Projekt ergeben sich daraus klare Anforderungen:

1. Keine permanente Speicherung: Das System darf nicht dauerhaft speichern, sondern nur in einem ringförmigen Puffer vorhalten.
2. KI als intelligenter Trigger: Die KI-gestützte Erkennung von Kollisionssituationen kann als intelligenter Trigger dienen – sie ersetzt den einfachen Erschütterungssensor durch ein komplexeres, situationsbewussteres Auslösesystem.
3. Minimierte Datenspeicherung: Neben der Videosequenz sollten nur die unbedingt erforderlichen Telemetriedaten (GPS, Geschwindigkeit, Zeitstempel) gespeichert werden.
4. Transparenz: Der Fahrer muss wissen, wann das System aufzeichnet und welche Daten gespeichert werden. Eine optische Anzeige (LED) während der Aufzeichnung ist empfehlenswert.

Teil 4: Kennzeichenerkennung – Technische Machbarkeit und rechtliche Grenzen

Die technische Umsetzung

Die automatische Kennzeichenerkennung (ANPR) ist auf dem Coral Dev Board technisch machbar. Die Edge TPU kann mit trainierten OCR-Modellen Kennzeichen in Echtzeit erfassen:

python

import cv2
import pytesseract
from pycoral.adapters import common
from pycoral.utils import edgetpu

class ANPRSystem:
    def __init__(self, plate_detector_model, ocr_model=None):
        self.plate_detector = edgetpu.make_interpreter(plate_detector_model)
        self.plate_detector.allocate_tensors()
        self.ocr = ocr_model or pytesseract
        
    def detect_plates(self, frame):
        """Erkennt Kennzeichenregionen im Bild"""
        # Plattenerkennung mit Edge TPU
        common.set_input(self.plate_detector, frame)
        self.plate_detector.invoke()
        # Bounding Boxes extrahieren
        return self.extract_boxes()
    
    def recognize_plate(self, roi):
        """Erkennt den Text auf einem Kennzeichen"""
        # Vorverarbeitung: Graustufen, Kontrast, Schärfung
        gray = cv2.cvtColor(roi, cv2.COLOR_BGR2GRAY)
        processed = self.preprocess(gray)
        # OCR mit Tesseract
        text = pytesseract.image_to_string(processed, 
                                           config='--psm 8 -c tessedit_char_whitelist=ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789')
        return text.strip()
    
    def process_frame(self, frame, gps_data, whitelist=None):
        plates = self.detect_plates(frame)
        results = []
        for plate_roi in plates:
            text = self.recognize_plate(plate_roi)
            if whitelist and text in whitelist:
                # Treffer in Fahndungsliste
                self.save_hit(text, gps_data, time.time())
                results.append({'plate': text, 'hit': True})
            elif not whitelist:
                # Aufzeichnungsmodus (rechtlich problematisch!)
                self.save_all(text, gps_data, time.time())
                results.append({'plate': text, 'hit': False})
        return results

Der rechtliche Rahmen

Die Rechtslage zur automatischen Kennzeichenerfassung ist eindeutig: Eine massenhafte automatisierte Aufzeichnung von Kfz-Kennzeichen für Strafverfolgungszwecke ist unzulässig.

Die Konferenz der unabhängigen Datenschutzaufsichtsbehörden des Bundes und der Länder (DSK) unterscheidet zwischen zwei Betriebsmodi:

Die DSK stellte klar, dass selbst für Strafverfolgungsmaßnahmen eine umfassende Erfassung aller Verkehrsteilnehmer nicht zu rechtfertigen ist. Eine Ausweitung des Betroffenenkreises in dieser Größenordnung sei durch keinerlei Tatsachen begründbar.

Der Sonderfall Behördenfahrzeuge

Die Diskussion um Dashcams in Polizeifahrzeugen gewinnt zunehmend an Dynamik. Das Unabhängige Landeszentrum für Datenschutz Schleswig-Holstein berichtet, dass die Anschaffung von Dashcams für Streifenwagen geprüft werden soll. Zudem wird die Beschaffung der notwendigen Technik für die automatische Kennzeichenerkennung zur Verfolgung von Straftaten vorangetrieben.

In Sachsen-Anhalt sollen künftig Kennzeichen von Autos automatisch überwacht werden, und auch Sachsens neues Polizeigesetz sieht die verdeckte automatisierte Kennzeichenerkennung vor.

Implikationen für das Projekt

1. Kein Aufzeichnungsmodus: Die systematische Speicherung aller erfassten Kennzeichen mit Standort ist rechtlich unzulässig.
2. Fahndungsmodus als Ausnahme: Ein reiner Abgleich mit einer Fahndungsliste – ohne dauerhafte Speicherung von Nicht-Treffern – wäre rechtlich tragbar, setzt jedoch eine entsprechende behördliche Berechtigung voraus.
3. Anlassbezogene Speicherung: Wie bei der Dashcam-Aufzeichnung gilt auch hier: Nur bei einem konkreten Anlass (Unfall, Gefahrensituation) dürfen Kennzeichen und Standort gespeichert werden.
4. Keine private Nutzung: Privatpersonen ist die systematische Kennzeichenerfassung und -speicherung im öffentlichen Raum grundsätzlich untersagt.

Teil 5: Einsatzszenarien und Zukunftsperspektiven

Szenario 1: Private Unfallbeweissicherung

Das klassische Einsatzszenario: Zwei Kameras (vorne/hinten) zeichnen im Loop-Modus auf. Bei einem Unfall oder einer kritischen Situation wird die Sequenz dauerhaft gespeichert – inklusive GPS-Daten, Geschwindigkeit und KI-annotierter Objekterkennung.

Vorteile gegenüber herkömmlichen Dashcams:

• KI-gestützte Kollisionserkennung statt einfacher Erschütterungssensoren
• Automatische Annotation von Verkehrsteilnehmern
• Präzise Telemetriedaten für die Unfallrekonstruktion

Szenario 2: Behördlicher Einsatz (Fahndungsmodus)

Polizeifahrzeuge könnten mit dem System ausgestattet werden, um Kennzeichen automatisch mit Fahndungslisten abzugleichen. Bei einem Treffer wird das Fahrzeug mit Standort und Zeitstempel protokolliert – ohne dass alle anderen Kennzeichen gespeichert werden.

Technische Anforderungen:

• Verschlüsselte Kommunikation mit der Fahndungsdatenbank
• Automatische Löschung von Nicht-Treffern
• Integritätsschutz der gespeicherten Daten (Beweissicherung)

Szenario 3: Überwachung neuralgischer Punkte

An neuralgischen Punkten – etwa an Grenzübergängen, Autobahnraststätten oder in der Nähe von Gefahrengebieten – könnten stationäre Systeme mit Coral-Technologie eingesetzt werden. Auch hier gilt: Nur der Fahndungsmodus ist rechtlich zulässig, nicht die Massenspeicherung.

Szenario 4: Flottenmanagement

Speditionen und Logistikunternehmen könnten das System nutzen, um das Fahrverhalten ihrer Fahrer zu analysieren, Unfälle zu rekonstruieren und die Sicherheit zu verbessern – immer unter der Maßgabe, dass die Aufzeichnung anlassbezogen erfolgt.

Szenario 5: Smart City-Integration

In Zukunft könnten solche Systeme mit städtischer Infrastruktur kommunizieren: Verkehrsflussanalyse, Ampelphasenoptimierung, automatische Meldung von Gefahrenstellen. Die technischen Voraussetzungen sind gegeben – die rechtlichen und gesellschaftlichen Fragen bleiben.

Zukunftsperspektiven

Die technische Entwicklung schreitet unaufhaltsam voran. Die geplante Einführung eines gemeinsamen Datenhauses der Polizei (Programm P20), in dem alle Daten der Länder- und Bundespolizeien gespeichert werden sollen, zeigt, wohin die Reise gehen könnte.

Gleichzeitig wird die Diskussion um den Einsatz von KI bei der Polizei durch das Bundesverfassungsgericht weiter begleitet. Die Entscheidung, ob und in welchem Umfang KI-gestützte Kennzeichenerfassungssysteme im öffentlichen Raum eingesetzt werden dürfen, wird letztlich eine gesellschaftliche und rechtliche sein – keine technische.

Fazit

Die KI-Dashcam auf Basis zweier Google Coral Dev Boards ist ein faszinierendes Projekt, das an der Schnittstelle von Elektrotechnik, Informatik und Rechtswissenschaft angesiedelt ist. Technisch ist die Umsetzung machbar – die Edge TPU bietet genügend Leistung für Echtzeit-Objekterkennung, und die Kommunikation zwischen den Boards und einem zentralen Mini-PC ist mit heutigen Netzwerktechnologien problemlos realisierbar.

Die rechtliche Dimension bleibt jedoch eine Herausforderung. Die aktuelle Rechtsprechung öffnet zwar die Tür für die Verwertung von Dashcam-Aufnahmen als Beweismittel, aber die permanente Aufzeichnung ohne Anlass bleibt unzulässig. Die KI-gestützte, ereignisbasierte Aufzeichnung könnte hier einen Ausweg bieten: Sie speichert nur dann, wenn die KI eine kritische Situation erkennt – und ersetzt damit den simplen Erschütterungssensor durch ein intelligenteres, situationsbewussteres System.

Die Kennzeichenerkennung ist technisch trivial, aber rechtlich höchst sensibel. Der Fahndungsmodus ist zulässig, der Aufzeichnungsmodus nicht. Wer ein solches System baut, muss diese Grenzen kennen und respektieren.

Die Zukunft wird zeigen, ob solche KI-gestützten Systeme den Weg in den Massenmarkt finden. Die technischen Voraussetzungen sind gegeben, die rechtlichen Rahmenbedingungen entwickeln sich, und das Bewusstsein für die Vorteile intelligenter Fahrerassistenz wächst. Vielleicht sehen wir schon bald nicht mehr nur Dashcams, die filmen – sondern Dashcams, die denken.

Quellen

• Google Coral: Dev Board Spezifikationen
• Google Coral: Dev Board Mini Produktseite
• Google Coral: Models – Object Detection
• Google Coral: Models – Image Classification
• GitHub: bastiankrohg/detection – Object Detection mit Coral Edge TPU
• Auto Motor und Sport: „Dashcam-Aufnahmen für TikTok, Youtube und Co.: Das ist erlaubt, und DAS nicht“, 28.12.2025
• Auto Motor und Sport: „Rechtstipp Dashcam-Videos vor Gericht“, 30.12.2025
• Bundesgerichtshof, Urteil vom 15.05.2018, Az.: VI ZR 233/17
• DSK: Entschließung zur automatischen Kennzeichenerkennung
• Frigate: Open-Source-NVR mit Coral-Integration
• MDR: „Das sind die Eckpunkte für Sachsens neues Polizeigesetz“, 02.10.2025
• MDR: „Neues Polizeigesetz: Sachsen-Anhalt will automatische Kennzeichenerfassung einführen“, 15.01.2025