Für OpenMV-Firmware v5.0.0 · basierend auf MicroPython v1.28 · Dokumentation erstellt 19. Juni 2026

Maschinelles Sehen,
leicht gemacht.

Live-Gesichtserkennung, AprilTag-Verfolgung, QR-Scanning und YOLO. Alles auf dem Gerät in reinem MicroPython. Kein Host-Computer, keine Cloud.

Neuigkeiten OpenMV-Firmware v5.0.0 Changelog lesen

Hallo Welt

import csi
import time
import ml
from ml.postprocessing.ultralytics import YoloV8

csi0 = csi.CSI()
csi0.reset()
csi0.pixformat(csi.RGB565)
csi0.framesize(csi.VGA)
csi0.snapshot(time=2000)  # let AWB/AGC stabilize

# Built-in single-class person detector model.
model = ml.Model("/rom/yolov8n_192.tflite",
                 postprocess=YoloV8(threshold=0.4))
clock = time.clock()

while True:
    clock.tick()
    img = csi0.snapshot()
    # predict returns a list per class of ((x, y, w, h), score) tuples.
    for class_dets in model.predict([img]):
        for rect, score in class_dets:
            img.draw_rectangle(rect, color=(0, 255, 0))
    print(clock.fps(), "fps")

Personenverfolgung in Echtzeit

Das integrierte YOLOv8-Modell ist ein Einzelklassen-Personendetektor — int8-quantisiert und im ROM enthalten.

Geladen von /rom/yolov8n_192.tflite — keine SD-Karte oder Download erforderlich.
Läuft in Echtzeit auf NPU-ausgestatteten Boards — dem OpenMV N6 und AE3.
Ein eigenes YOLOv8-Modell, trainiert auf Roboflow, auf die gleiche Weise laden.
import csi
import math
import time

csi0 = csi.CSI()
csi0.reset()
csi0.pixformat(csi.RGB565)
csi0.framesize(csi.QVGA)
csi0.snapshot(time=2000)  # let AWB/AGC stabilize
csi0.auto_gain(False)
csi0.auto_whitebal(False)

clock = time.clock()

while True:
    clock.tick()
    img = csi0.snapshot()
    for tag in img.find_apriltags():
        img.draw_detection(tag, color1=(255, 0, 0), color2=(0, 255, 0))
        deg = math.degrees(tag.rotation)
        print("ID %d  rotation %.1f deg" % (tag.id, deg))
    print(clock.fps(), "fps")

AprilTags lokalisieren und identifizieren

AprilTags sind 2D-Referenzmarker — robust gegen Bewegungsunschärfe und teilweise Verdeckung, und liefern die vollständige 3D-Pose.

Eingebauter Detektor — keine Modelldatei oder Training erforderlich.
Gibt ID und vollständige 6-DoF-Pose zurück — x/y/z-Translation und x/y/z-Rotation.
Für Roboterkalibrierung, AR-Marker und Innenraumpositionierung geeignet.
import csi
import time
import ml
from ml.postprocessing.mediapipe import BlazeFace

csi0 = csi.CSI()
csi0.reset()
csi0.pixformat(csi.RGB565)
csi0.framesize(csi.VGA)
csi0.window((400, 400))  # square window for best results
csi0.snapshot(time=2000)  # let AWB/AGC stabilize

model = ml.Model("/rom/blazeface_front_128.tflite",
                 postprocess=BlazeFace(threshold=0.4))
clock = time.clock()

while True:
    clock.tick()
    img = csi0.snapshot()
    for rect, score, keypoints in model.predict([img]):
        img.draw_rectangle(rect, color=(0, 0, 255))
        ml.utils.draw_keypoints(img, keypoints, color=(255, 0, 0))
    print(clock.fps(), "fps")

Gesichter mit BlazeFace erkennen

Googles BlazeFace ist ein schlanker TensorFlow Lite-Gesichtsdetektor, der Begrenzungsrahmen und sechs Landmarken pro Gesicht zurückgibt.

Geladen von /rom/blazeface_front_128.tflite — vorquantisiert, kein Download erforderlich.
Sechs Schlüsselpunkte pro Gesicht: Augen, Nase, Mund und Ohren.
Keine Datenschutzbedenken — Bilder verlassen die Kamera nie.
import csi
import time

csi0 = csi.CSI()
csi0.reset()
csi0.pixformat(csi.RGB565)
csi0.framesize(csi.QVGA)
csi0.snapshot(time=2000)  # let AWB/AGC stabilize
csi0.auto_gain(False)

clock = time.clock()

while True:
    clock.tick()
    img = csi0.snapshot()
    for code in img.find_qrcodes():
        img.draw_rectangle(code.rect, color=(255, 0, 0))
        print(code.payload)
    print(clock.fps(), "fps")

QR-Codes aus einem Live-Bild scannen

Der eingebaute QR-Decoder verarbeitet gekippte, verzerrte und teilweise verdeckte Codes.

Jedes Ergebnis enthält auch Version, ECC-Stufe und Eckkoordinaten.
Numerische, alphanumerische, binäre und Kanji-Datenmodi.
Gibt die dekodierte Nutzlast als Python-Zeichenkette zurück — sofort einsatzbereit.
import csi
import time

csi0 = csi.CSI()
csi0.reset()
csi0.pixformat(csi.RGB565)
csi0.framesize(csi.QVGA)
csi0.snapshot(time=2000)  # let AWB/AGC stabilize
csi0.auto_gain(False)
csi0.auto_whitebal(False)

# LAB thresholds: (L_min, L_max, A_min, A_max, B_min, B_max)
thresholds = [
    (30, 100, 15, 127, 15, 127),   # red
    (30, 100, -64, -8, -32, 32),   # green
]

clock = time.clock()

while True:
    clock.tick()
    img = csi0.snapshot()
    for blob in img.find_blobs(thresholds, pixels_threshold=200):
        img.draw_rectangle(blob.rect, color=(255, 0, 0))
        img.draw_cross((blob.cx, blob.cy))
    print(clock.fps(), "fps")

Farbbereiche finden

find_blobs gibt zusammenhängende Pixelbereiche zurück, die einem oder mehreren LAB-Schwellenwerten entsprechen.

Schwellenwerte an die Beleuchtung anpassen — zuerst Auto-Gain und Auto-Weißabgleich deaktivieren.
Mehrere Schwellenwerte für Mehrfarbverfolgung in einem einzigen Aufruf übergeben.
pixels_threshold filtert winzige Erkennungen; merge=True verbindet überlappende Bereiche.
import csi
import time

csi0 = csi.CSI()
csi0.reset()
csi0.pixformat(csi.GRAYSCALE)
csi0.framesize(csi.VGA)
csi0.window((640, 80))  # narrow strip for fast linear scanning
csi0.snapshot(time=2000)  # let AWB/AGC stabilize
csi0.auto_gain(False)
csi0.auto_whitebal(False)

clock = time.clock()

while True:
    clock.tick()
    img = csi0.snapshot()
    for code in img.find_barcodes():
        img.draw_rectangle(code.rect, color=(0, 255, 0))
        print(code.payload, "(quality %d)" % code.quality)
    print(clock.fps(), "fps")

1D-Barcodes lesen

1D-Barcodes an beliebiger Stelle im Bild finden und deren Inhalte dekodieren.

Unterstützt durch die ZBar-Bibliothek — erkennt EAN, UPC, Code 39/93/128, Codabar, ITF, ISBN und DataBar.
Einen Graustufenstreifen als Fenster für den schnellsten Linearscan verwenden.
Jedes Ergebnis enthält Format, Nutzlast, Rotation, Ecken und ein Begrenzungsrechteck.
import csi
import time
import ml
from ml.postprocessing.mediapipe import HandLandmarks

csi0 = csi.CSI()
csi0.reset()
csi0.pixformat(csi.RGB565)
csi0.framesize(csi.VGA)
csi0.window((400, 400))  # square window for the model
csi0.snapshot(time=2000)  # let AWB/AGC stabilize

# Connections between the 21 keypoints — palm + 5 fingers.
hand_lines = ((0, 1), (1, 2), (2, 3), (3, 4), (0, 5), (5, 6),
              (6, 7), (7, 8), (5, 9), (9, 10), (10, 11), (11, 12),
              (9, 13), (13, 14), (14, 15), (15, 16), (13, 17), (17, 18),
              (18, 19), (19, 20), (0, 17))

model = ml.Model("/rom/hand_landmarks_full_224.tflite",
                 postprocess=HandLandmarks(threshold=0.4))
clock = time.clock()

while True:
    clock.tick()
    img = csi0.snapshot()
    # predict returns a list per hand: index 0 = left, index 1 = right.
    for detections in model.predict([img]):
        for rect, score, keypoints in detections:
            ml.utils.draw_skeleton(img, keypoints, hand_lines,
                                   kp_color=(255, 0, 0),
                                   line_color=(0, 255, 0))
    print(clock.fps(), "fps")

21 Hand-Schlüsselpunkte verfolgen

Googles MediaPipe-Hand-Landmarken-Modell platziert 21 Gelenke auf jeder erkannten Hand — Handgelenk, Knöchel und Fingerspitzen.

Geladen von /rom/hand_landmarks_full_224.tflite — hier eigenständig ausgeführt, ohne vorgelagerte Handflächen-Erkennung.
Gibt eine Liste pro Hand zurück — Index 0 ist links, Index 1 ist rechts.
ml.utils.draw_skeleton zeichnet alle 21 Gelenke und Verbindungen in einem einzigen Aufruf.

Neu bei OpenMV?

Mit dem schrittweisen Tutorial beginnen — es behandelt Hardware-Einrichtung, die IDE, grundlegende Skripte und Tipps für das erste echte Projekt.

Kernbibliotheken

Hardware, Kameras, Bildverarbeitung, ndarrays, ML, Multitasking, Netzwerk, Webserver und Bluetooth — alles aus MicroPython.

Alle Bibliotheken anzeigen →

Nach Board erkunden

OpenMV Cam auswählen, um Pinbelegung, technische Daten und boardspezifische Kurzreferenz anzuzeigen.

Alle unterstützten Boards anzeigen →

Shields

Erweiterungsboards, die in die OpenMV Cam eingesteckt werden — Netzwerk, Motorsteuerung, Displays und mehr.

Alle Shields anzeigen →

Sensoren

Kameramodule und Sensoradapter, die in den Board-to-Board-Stecker eingesteckt werden — Farb-, Monochrom-, Wärme- und ereignisbasierte Bilderfassung.

Alle Sensoren anzeigen →

Weitere Ressourcen

Community & Links