Para OpenMV versión v5.0.0 · basado en MicroPython v1.28 · documentación generada el 19 de junio de 2026

Visión artificial,
simplificada.

Detección de rostros en vivo, seguimiento de AprilTag, lectura de QR y YOLO. Todo en el dispositivo con puro MicroPython. Sin ordenador host, sin nube.

Guía de inicio rápido Referencia de la API Encuentra tu placa
Novedades Leer el registro de cambios de OpenMV v5.0.0
1

Abrir el IDE

Descarga e instala OpenMV IDE para Windows, macOS o Linux e inicia el IDE.
2

Conecta tu cámara

Conecta la OpenMV Cam a tu ordenador por USB. Un LED azul parpadea cuando está lista.
3

Ejecuta tu primer script

Haz clic en el botón de conexión con icono de enchufe en el IDE y luego pulsa la flecha verde de reproducción para ejecutar tu primer script.

Hola mundo

Ejemplos
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")

Seguimiento de personas en tiempo real

El modelo YOLOv8 integrado es un detector de personas de una sola clase — cuantificado en int8 e incluido en ROM.

Cargado desde /rom/yolov8n_192.tflite — no se necesita tarjeta SD ni descarga.
Se ejecuta en tiempo real en placas con NPU — la OpenMV N6 y la AE3.
Usa tu propio modelo YOLOv8 entrenado en Roboflow y cárgalo de la misma manera.
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")

Localiza e identifica AprilTags

Los AprilTags son marcadores fiduciales 2D — robustos ante el desenfoque de movimiento y oclusión parcial, y proporcionan pose 3D completa.

Detector integrado — no se necesita archivo de modelo ni entrenamiento.
Devuelve el ID más la pose completa de 6 DoF — traslación x/y/z y rotación x/y/z.
Útil para calibración robótica, marcadores de RA y posicionamiento en interiores.
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")

Detecta rostros con BlazeFace

BlazeFace de Google es un detector de rostros TensorFlow Lite ligero que devuelve cajas delimitadoras más seis puntos de referencia por rostro.

Cargado desde /rom/blazeface_front_128.tflite — precuantificado, no se necesita descarga.
Seis puntos clave por rostro: ojos, nariz, boca y orejas.
Sin preocupaciones de privacidad — los fotogramas nunca salen de la cámara.
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")

Escanea códigos QR desde una transmisión en vivo

El decodificador QR integrado gestiona códigos inclinados, distorsionados y parcialmente ocluidos.

Cada resultado también expone versión, nivel ECC y coordenadas de las esquinas.
Modos de datos numérico, alfanumérico, binario y Kanji.
Devuelve el contenido decodificado como cadena Python — listo para usar.
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")

Encuentra manchas de color

find_blobs devuelve regiones de píxeles conectadas que coinciden con uno o más umbrales LAB.

Ajusta los umbrales según tu iluminación — desactiva primero la ganancia automática y el balance de blancos automático.
Pasa múltiples umbrales para seguimiento multicolor en una sola llamada.
pixels_threshold filtra detecciones pequeñas; merge=True une manchas solapadas.
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")

Lee códigos de barras 1D

Encuentra códigos de barras 1D en cualquier parte del fotograma y decodifica su contenido.

Impulsado por la biblioteca ZBar — reconoce EAN, UPC, Code 39/93/128, Codabar, ITF, ISBN y DataBar.
Usa una franja de ventana en escala de grises para el escaneo lineal más rápido.
Cada resultado tiene formato, contenido, rotación, esquinas y un rectángulo delimitador.
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")

Rastrea 21 puntos clave de la mano

El modelo Hand Landmarks de Google MediaPipe sitúa 21 articulaciones en cada mano detectada — muñeca, nudillos y yemas de los dedos.

Cargado desde /rom/hand_landmarks_full_224.tflite — se ejecuta de forma independiente aquí, sin detección de palma previa.
Devuelve una lista por mano — el índice 0 es la izquierda, el índice 1 es la derecha.
ml.utils.draw_skeleton dibuja las 21 articulaciones y sus conexiones en una sola llamada.

¿Nuevo en OpenMV?

Comienza con el tutorial paso a paso — cubre la configuración del hardware, el IDE, scripts básicos y consejos para tu primer proyecto real.

Bibliotecas principales

API

Hardware, cámaras, procesamiento de imagen, ndarrays, ML, multitarea, redes, servidores web y Bluetooth — todo desde MicroPython.

machine

Hardware de bajo nivel: GPIO, SPI, I²C, UART, PWM, ADC y temporizadores.

Explorar →

csi

Control de cámara: formatos de píxel, tamaños de fotograma, exposición, ganancia y balance de blancos.

Explorar →

image

Visión artificial: manchas, bordes, líneas, círculos, características y dibujo.

Explorar →

ulab

Computación numérica en el dispositivo — ndarrays, FFT y álgebra lineal.

Explorar →

ml

Inferencia de redes neuronales en el dispositivo — clasificar, detectar y segmentar.

Explorar →

asyncio

Multitarea cooperativa — ejecuta cámara, red y E/S en paralelo.

Explorar →

network

Wi-Fi, Ethernet y sockets para IoT y comunicación remota.

Explorar →

microdot

Servidor HTTP mínimo — rutas, sesiones, inicio de sesión, SSE y WebSockets.

Explorar →

aioble

Bluetooth Low Energy asíncrono — periféricos, publicidad y GATT.

Explorar →

Ver todas las bibliotecas →

Explorar por placa

Hardware

Selecciona tu OpenMV Cam para ver su diagrama de pines, especificaciones y referencia rápida específica de la placa.

OpenMV N6

OpenMV N6 Nuevo

STM32N6 con NPU integrado — el primer MCU con aceleración de IA de STMicro.

Explorar →
OpenMV AE3

OpenMV AE3 Nuevo

Alif Ensemble E3 — Cortex-M55 de clase fusión con NPU Ethos-U55.

Explorar →
OpenMV RT1062

OpenMV RT1062

NXP i.MX RT1062 Cortex-M7 a 600 MHz con 32 MB de SDRAM externo.

Explorar →
OpenMV H7 Plus

OpenMV H7 Plus

STM32H743 con 32 MB de SDRAM externo y un sensor OV5640 de 5MP.

Explorar →
OpenMV H7

OpenMV H7

STM32H743 Cortex-M7 con módulo de sensor de imagen extraíble.

Explorar →
Arduino Nicla Vision

Arduino Nicla Vision

Placa STM32H747 compacta de 23 × 23 mm con sensor integrado.

Explorar →
Arduino Portenta H7

Arduino Portenta

STM32H747 con 8 MB de SDRAM y soporte para Vision Shield.

Explorar →
Arduino Giga

Arduino Giga

STM32H747 con 8 MB de SDRAM y soporte para Vision y Display Shield.

Explorar →

Ver todas las placas compatibles →

Shields

Complementos

Placas complementarias que se conectan a la OpenMV Cam — redes, control de motores, pantallas y más.

Gigabit PoE Shield

Gigabit PoE Shield

Ethernet Gigabit con PoE para transmisión de mayor ancho de banda.

Explorar →
Servo Shield

Servo Shield

Controla hasta 4 servos con hasta 5 A mientras alimenta la cámara, entrada de 6–36 V.

Explorar →
Battery Shield

Battery Shield

Entrada de batería de 1,8–5,5 V mediante conector DC barrel jack.

Explorar →
Touch LCD Shield

Touch LCD Shield

LCD SPI de 2,3" con pantalla táctil capacitiva multitáctil y Qwiic.

Explorar →
PoE Shield

PoE Shield

Ethernet 10/100 con Power-over-Ethernet.

Explorar →
PIR Shield

PIR Shield

Detector de movimiento en espera de 6 µA más luz IR blanca y de 850 nm.

Explorar →
CAN/RS232 Shield

CAN/RS232 Shield

CAN-FD a 8 Mb/s más RS-232 a 1 Mb/s en un shield.

Explorar →
RS422/RS485 Shield

RS422/RS485 Shield

Serie diferencial a 10 Mb/s para buses industriales.

Explorar →

Ver todos los shields →

Sensores

Módulos de cámara

Módulos de cámara y adaptadores de sensor que se conectan al conector de placa a placa — visión en color, monocromática, térmica y basada en eventos.

PS5520 5MP HDR Camera

PS5520 5MP HDR Camera

Sensor HDR de 5MP — alto rango dinámico para iluminación difícil.

Explorar →
Multispectral Thermal (PAG7936)

Multispectral Thermal (PAG7936)

Color de 1 MP con obturador global + cámara térmica FLIR Lepton en un módulo.

Explorar →
Multispectral Thermal (OV5640)

Multispectral Thermal (OV5640)

Color de 5MP con obturador rodante + cámara térmica FLIR Lepton en un módulo.

Explorar →
Multispectral Event Camera

Multispectral Event Camera

Sensor de eventos GENX320 + color PAG7936 en un módulo.

Explorar →
GENX320 Event Camera

GENX320 Event Camera

Visión basada en eventos Prophesee — precisión temporal de microsegundos.

Explorar →
FLIR Boson Adapter

FLIR Boson Adapter

Adaptador para FLIR Boson / Boson+ — cámara térmica de mayor resolución.

Explorar →
FLIR Lepton Adapter

FLIR Lepton Adapter

Adaptador para núcleos térmicos FLIR Lepton 1.x / 2.x / 3.x.

Explorar →
Global Shutter Camera Module

Global Shutter Camera Module

Sensor monocromático de obturador global para captura de movimiento rápido.

Explorar →

Ver todos los sensores →

Más recursos

MicroPython

Lenguaje OpenMV MicroPython

Referencia del lenguaje, sintaxis y semántica básica del tiempo de ejecución.

Diferencias respecto a CPython

Dónde MicroPython difiere del Python estándar — módulos, funciones integradas y sintaxis.

Internos de OpenMV MicroPython

Compilador, tiempo de ejecución, módulos nativos y portabilidad de MicroPython a nuevos MCU.

Comunidad & enlaces

Externo

Página principal de OpenMV

Productos, aplicaciones, descargas y noticias.

Foros

Discusión comunitaria, ayuda y compartición de proyectos.

OpenMV en GitHub

Fuentes del firmware, IDE y ejemplos — se aceptan issues y pull requests.

MicroPython en GitHub

Fuentes del firmware MicroPython original — sobre lo que OpenMV construye.