Para o firmware OpenMV v5.0.0 · baseado em MicroPython v1.28 · documentação compilada em 18 de junho de 2026

Visão por computador,
simplificada.

Deteção de faces em tempo real, rastreamento de AprilTag, leitura de QR e YOLO. Tudo no dispositivo em MicroPython puro. Sem computador anfitrião, sem nuvem.

Guia de início rápido Referência de API Encontrar a sua placa

Novidades Ler o changelog do firmware OpenMV v5.0.0

1

Abrir o IDE

Descarregue e instale o OpenMV IDE para Windows, macOS ou Linux e inicie o IDE.

2

Ligar a sua câmara

Ligue a OpenMV Cam ao seu computador via USB. Um LED azul de pulsação pisca quando está pronta.

3

Executar o seu primeiro script

Clique no botão de ligação com ícone de tomada no IDE, depois prima a seta verde de reprodução para executar o seu primeiro script.

Olá, mundo

Exemplos

Rastreamento de pessoas com YOLOv8 Rastreamento de AprilTag Rastreamento de BlazeFace Deteção de código QR Rastreamento de cor Deteção de código de barras Pontos de referência de mãos

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

Rastreamento de pessoas em tempo real

O modelo YOLOv8 integrado é um detetor de pessoas de classe única — quantizado em int8 e fornecido em ROM.

Carregado de /rom/yolov8n_192.tflite — sem cartão SD nem descarga necessária.

Executa em tempo real em placas equipadas com NPU — o OpenMV N6 e AE3.

Carregue o seu próprio modelo YOLOv8 treinado no Roboflow e carregue-o da mesma forma.

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

Localizar e identificar AprilTags

Os AprilTags são marcadores fiduciais 2D — robustos ao desfoque de movimento e oclusão parcial, e fornecem pose 3D completa.

Detetor integrado — não necessita de ficheiro de modelo nem de treino.

Devolve ID mais pose completa de 6-DoF — translação x/y/z e rotação x/y/z.

Use para calibração de robótica, marcadores AR e posicionamento interior.

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

Detetar faces com BlazeFace

O BlazeFace da Google é um detetor de faces TensorFlow Lite leve que devolve caixas delimitadoras mais seis pontos de referência por face.

Carregado de /rom/blazeface_front_128.tflite — pré-quantizado, sem necessidade de descarga.

Seis pontos-chave por face: olhos, nariz, boca e orelhas.

Sem preocupações de privacidade — os fotogramas nunca saem da 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")

Ler códigos QR a partir de uma transmissão em direto

O descodificador QR integrado trata de códigos inclinados, distorcidos e parcialmente ocluídos.

Cada resultado também expõe a versão, nível ECC e coordenadas dos cantos.

Modos de dados numérico, alfanumérico, binário e Kanji.

Devolve o conteúdo descodificado como uma string Python — pronto a 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")

Encontrar manchas de cor

find_blobs devolve regiões de pixels ligados que correspondem a um ou mais limiares LAB.

Ajuste os limiares para a sua iluminação — desative o ganho automático e o balanço de brancos automático primeiro.

Passe múltiplos limiares para rastreamento multi-cor numa única chamada.

pixels_threshold filtra deteções pequenas; merge=True une manchas sobrepostas.

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

Ler códigos de barras 1D

Localize códigos de barras 1D em qualquer parte do fotograma e descodifique os seus conteúdos.

Desenvolvido pela biblioteca ZBar — reconhece EAN, UPC, Code 39/93/128, Codabar, ITF, ISBN e DataBar.

Use uma faixa com janela em escala de cinzentos para a leitura linear mais rápida.

Cada resultado tem formato, conteúdo, rotação, cantos e um 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")

Rastrear 21 pontos-chave de mão

O modelo Hand Landmarks do MediaPipe da Google coloca 21 articulações em cada mão detetada — pulso, nós dos dedos e pontas dos dedos.

Carregado de /rom/hand_landmarks_full_224.tflite — a executar de forma autónoma aqui, sem deteção de palma a montante.

Devolve uma lista por mão — índice 0 é a esquerda, índice 1 é a direita.

ml.utils.draw_skeleton desenha todas as 21 articulações e ligações numa única chamada.

Novo no OpenMV?

Comece com o tutorial passo a passo — cobre a configuração do hardware, o IDE, scripts básicos e dicas para o seu primeiro projeto real.

Bibliotecas principais

API

Hardware, câmaras, processamento de imagem, ndarrays, ML, multitarefa, redes, servidores web e Bluetooth — tudo em MicroPython.

machine

Hardware de baixo nível: GPIO, SPI, I²C, UART, PWM, ADC e temporizadores.

Explorar →

csi

Controlo de câmara: formatos de pixel, tamanhos de fotograma, exposição, ganho e balanço de brancos.

Explorar →

image

Visão por computador: manchas, arestas, linhas, círculos, características e desenho.

Explorar →

ulab

Computação numérica no dispositivo — ndarrays, FFTs e álgebra linear.

Explorar →

ml

Inferência de rede neuronal no dispositivo — classificação, deteção e segmentação.

Explorar →

asyncio

Multitarefa cooperativa — execute câmara, rede e E/S em paralelo.

Explorar →

network

Wi-Fi, Ethernet e sockets para IoT e comunicação remota.

Explorar →

microdot

Servidor HTTP minimalista — rotas, sessões, autenticação, SSE e WebSockets.

Explorar →

aioble

Bluetooth Low Energy assíncrono — periféricos, anúncio e GATT.

Explorar →

Ver todas as bibliotecas →

Explorar por placa

Hardware

Selecione a sua OpenMV Cam para ver o seu pinout, especificações e referência rápida específica da placa.

OpenMV N6 Novo

STM32N6 com NPU integrada — primeiro MCU com aceleração de IA da STMicro.

Explorar →

OpenMV AE3 Novo

Alif Ensemble E3 — Cortex-M55 de classe fusion com NPU Ethos-U55.

Explorar →

OpenMV RT1062

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

Explorar →

OpenMV H7 Plus

STM32H743 com 32 MB de SDRAM externo e um sensor OV5640 de 5 MP.

Explorar →

OpenMV H7

STM32H743 Cortex-M7 com um módulo de sensor de imagem amovível.

Explorar →

Arduino Nicla Vision

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

Explorar →

Arduino Portenta

STM32H747 com 8 MB de SDRAM e suporte para Vision Shield.

Explorar →

Arduino Giga

STM32H747 com 8 MB de SDRAM, suporte para Vision Shield e Display Shield.

Explorar →

Ver todas as placas suportadas →

Shields

Expansões

Placas de expansão que se ligam à OpenMV Cam — conectividade de rede, controlo de motores, ecrãs e muito mais.

Gigabit PoE Shield

Ethernet Gigabit com PoE para transmissão de maior largura de banda.

Explorar →

Servo Shield

Alimente até 4 servos com até 5 A enquanto alimenta a câmara, entrada de 6–36 V.

Explorar →

Battery Shield

Entrada de bateria de 1,8–5,5 V via conector de barril DC.

Explorar →

Touch LCD Shield

LCD SPI de 2,3" com toque múltiplo capacitivo e Qwiic.

Explorar →

PoE Shield

Ethernet 10/100 com Power-over-Ethernet.

Explorar →

PIR Shield

Disparo de movimento em modo de espera de 6 µA com luz branca e IV de 850 nm.

Explorar →

CAN/RS232 Shield

CAN-FD de 8 Mb/s mais RS-232 de 1 Mb/s numa única shield.

Explorar →

RS422/RS485 Shield

Série diferencial de 10 Mb/s para barramentos industriais.

Explorar →

Ver todas as shields →

Sensores

Módulos de câmara

Módulos de câmara e adaptadores de sensor que se ligam ao conector placa a placa — visão a cores, monocromática, térmica e baseada em eventos.

PS5520 5MP HDR Camera

Sensor HDR de 5 MP — grande alcance dinâmico para condições de iluminação difíceis.

Explorar →

Multispectral Thermal (PAG7936)

1 sensor de obturador global a cores MP + FLIR Lepton térmico num único módulo.

Explorar →

Multispectral Thermal (OV5640)

5 MP de obturador deslizante a cores + FLIR Lepton térmico num único módulo.

Explorar →

Multispectral Event Camera

Sensor de eventos GENX320 + cores PAG7936 num único módulo.

Explorar →

GENX320 Event Camera

Visão baseada em eventos Prophesee — precisão temporal de microssegundos.

Explorar →

FLIR Boson Adapter

Adaptador para FLIR Boson / Boson+ — térmico de maior resolução.

Explorar →

FLIR Lepton Adapter

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

Explorar →

Global Shutter Camera Module

Sensor monocromático de obturador global para captura de movimentos rápidos.

Explorar →

Ver todos os sensores →

Mais recursos

MicroPython

Linguagem do OpenMV MicroPython

Referência de linguagem, sintaxe e semântica do runtime principal.

Diferenças em relação ao CPython

Onde o MicroPython diverge do Python standard — módulos, builtins e sintaxe.

Internos do OpenMV MicroPython

Compilador, runtime, módulos nativos e portabilidade do MicroPython para novos MCUs.

Comunidade & ligações

Externo

Página inicial do OpenMV

Produtos, aplicações, descarregamentos e notícias.

Fóruns

Discussão, ajuda e partilha de projetos na comunidade.

OpenMV no GitHub

Firmware, IDE e fontes de exemplos — questões e pedidos de integração são bem-vindos.

MicroPython no GitHub

Fontes do firmware MicroPython upstream — o que o OpenMV constrói em cima.