Câmera Raspberry Pi OV5647 5MP 1080p 3.6mm: Manual Técnico Completo

Introdução

Neste manual, será apresentado como instalar, configurar e utilizar a Câmera Raspberry Pi OV5647 5MP 1080p 3.6mm. Se desejar adquirir este produto, clique aqui.

Desenvolvida com base no consagrado sensor de imagem CMOS OmniVision OV5647 de matriz ativa QSXGA, esta placa de captura de vídeo entrega resolução nativa de 5 megapixels ($2592 \times 1944$ pixels) e suporte a gravação de vídeo em Full HD 1080p a $30\,\text{fps}$. Equipada com um conjunto óptico padrão M12 dotado de distância focal de $3{,}6\,\text{mm}$, abertura relativa $F1{,}8$ e anel de foco manual ajustável com parafuso de bloqueio, o módulo proporciona excelente nitidez geométrica com campo de visão diagonal de $60^\circ$, tornando-se a escolha ideal para monitoramento visual, robótica autônoma, visão computacional e streaming contínuo através da interface nativa MIPI CSI-2 do Raspberry Pi.

Especificações técnicas

O módulo integra o sensor de imagem de estado sólido OmniVision OV5647, regulador de tensão interno de baixo ruído (Low-Dropout — LDO), oscilador cerâmico e filtragem eletromagnética passiva, acompanhado de cabo plano flexível (FFC) padrão de 15 vias com passo (pitch) de $1{,}0\,\text{mm}$ para as portas dedicadas CSI do ecossistema Raspberry Pi.

Principais especificações

A tabela abaixo compila as propriedades ópticas, modos de amostragem de vídeo e características físicas do módulo:

Parâmetro	Especificação Técnica
Sensor de Imagem	OmniVision OV5647 (Color CMOS QSXGA)
Resolução Máxima Nativa	$2592 \times 1944$ pixels ($5{,}04\,\text{MP}$ efetivos)
Tamanho Óptico do Sensor	Formato $1/4^{\prime\prime}$ (diagonal de $4{,}5\,\text{mm}$)
Dimensão do Pixel	$1{,}4\,\mu\text{m} \times 1{,}4\,\mu\text{m}$ (Tecnologia OmniBSI™)
Distância Focal da Lente ($f$)	$3{,}6\,\text{mm}$
Abertura Relativa (F-number)	$F1{,}8 \pm 5\%$
Campo de Visão Diagonal (FOV)	$60^\circ$
Tipo de Encaixe da Lente	Rosca métrica padrão M12 com anel de foco giratório
Filtro de Bloqueio Óptico	Filtro IR-Cut integrado para espectro visível ($650\,\text{nm}$)
Interface de Vídeo de Alta Velocidade	MIPI CSI-2 ($2\,\text{data lanes} + 1\,\text{clock lane}$)
Largura de Banda por Via MIPI	Até $800\,\text{Mbps}$ por via diferencial
Interface de Controle de Registradores	Barramento serial bidirecional I2C / SCCB ($400\,\text{kHz}$)
Endereço I2C Padrão (7 bits)	0x36 (Registradores de identificação 0x300A e 0x300B)
Formatos de Saída de Sinal Bruto	RAW8, RAW10 (Matriz de filtro de cor Bayer RGB)
Resoluções e Taxas de Amostragem	$2592 \times 1944$ @ $15\,\text{fps}$ $1920 \times 1080$ (1080p) @ $30\,\text{fps}$ $1280 \times 720$ (720p) @ $60\,\text{fps}$ $640 \times 480$ (VGA) @ $60\,\text{fps}$ / $90\,\text{fps}$
Conector FFC da Placa	15 vias com trava deslizante, passo de $1{,}0\,\text{mm}$
Dimensões Físicas da PCB	$25{,}0\,\text{mm} \times 24{,}0\,\text{mm} \times 9{,}0\,\text{mm}$
Furos de Fixação	4 furos metálicos para parafusos M2 com espaçamento de $21\,\text{mm} \times 12{,}5\,\text{mm}$

Características elétricas e operacionais

O circuito da placa recebe a linha de alimentação primária de $3{,}3\,\text{V}$ proveniente do barramento CSI e gera internamente as tensões analógicas e digitais necessárias para a operação estável dos amplificadores de carga e conversores A/D:

Grandeza Elétrica / Operacional	Mínimo	Típico	Máximo	Unidade
Tensão de Alimentação do Módulo (VCC / 3V3)	$3{,}15$	$3{,}30$	$3{,}45$	$\text{V}$
Tensão Analógica do Núcleo ($V_{\text{AVDD}}$ - Interna)	$2{,}60$	$2{,}80$	$3{,}00$	$\text{V}$
Tensão Lógica Digital ($V_{\text{DVDD}}$ - Regulador Interno)	$1{,}40$	$1{,}50$	$1{,}60$	$\text{V}$
Tensão de I/O Digital ($V_{\text{DOVDD}}$)	$1{,}70$	$2{,}80$ / $3{,}30$	$3{,}45$	$\text{V}$
Corrente Ativa em Captura Contínua (1080p30)	$200$	$250$	$280$	$\text{mA}$
Corrente em Modo Standby / Power-Down	—	$20$	$50$	$\mu\text{A}$
Nível Lógico de Entrada Alto no Barramento I2C ($V_{IH}$)	$0{,}7 \times \text{VCC}$	—	$\text{VCC} + 0{,}3$	$\text{V}$
Nível Lógico de Entrada Baixo no Barramento I2C ($V_{IL}$)	$-0{,}3$	—	$0{,}3 \times \text{VCC}$	$\text{V}$
**Tensão Diferencial MIPI CSI-2 Alta Velocidade ($	V_{OD}	$)**	$150$	$200$
Tensão de Modo Comum MIPI CSI-2 ($V_{CMTX}$)	$150$	$200$	$250$	$\text{mV}$
Impedância Característica Diferencial MIPI	$85$	$100$	$115$	$\Omega$
Faixa de Temperatura de Operação	$-20$	$+25$	$+60$	$^\circ\text{C}$
Faixa de Temperatura para Imagem Estável	$0$	$+25$	$+50$	$^\circ\text{C}$

⚠️ Atenção: As linhas diferenciais de transmissão do padrão MIPI CSI-2 operam com excursões de sinal sub-volt na faixa de $200\,\text{mV}$ em frequências fundamentais superiores a centenas de megahertz. Jamais tente estender a ligação utilizando fios comuns, protoboards ou cabos sem casamento de impedância ($100\,\Omega$ diferencial), sob risco de colapso no sincronismo de quadros da GPU/ISP.

Descrição do produto

O que é a Câmera Raspberry Pi OV5647 5MP 3.6mm?

A Câmera Raspberry Pi OV5647 5MP 1080p 3.6mm é um módulo óptico-eletrônico miniaturizado projetado para captura de fotos de alta fidelidade e streaming de vídeo digital em placas de processamento embarcado da linha Raspberry Pi. No coração da placa encontra-se o circuito integrado OmniVision OV5647, fabricado sob a tecnologia Back-Illuminated Pixel (BSI), que realoca a camada de fiação metálica para trás dos fotodiodos de silício, maximizando a captação de luz e minimizando o ruído de corrente escura (dark current).

Ao contrário de câmeras USB padrão que comprimem os frames sob alta latência e sobrecarregam a CPU do sistema hospedeiro, este módulo transmite o fluxo de dados em formato RAW diretamente para o barramento MIPI CSI-2 (Camera Serial Interface). O processador de sinal de imagem (Image Signal Processor — ISP) do processador Broadcom assume em hardware as tarefas de interpolação de cor (demosaicing), ganho automático, balanceamento de branco e compressão H.264/JPEG, liberando os núcleos de processamento para tarefas analíticas.

Para que serve?

O módulo destina-se a sistemas ópticos dedicados, atendendo com confiabilidade às seguintes finalidades:

• Visão Computacional e Robótica Móvel: rastreamento de linhas, localização visual, reconhecimento de marcadores fiduciais (ArUco e AprilTags) e desvio de obstáculos;
• Segurança Eletrônica e Monitoramento: gravação de fluxos contínuos de vídeo em 1080p ou 720p em centrais NVR com acionamento por detecção de movimento;
• Inspeção Óptica Automatizada: leitura de códigos de barras, QR Codes e checagem dimensional de peças em linhas de produção educacionais e industriais.

Por que devo usar?

• Lente Rosqueável M12 com Foco Ajustável Manualmente: permite focalizar objetos em distâncias macro (a partir de poucos centímetros) até o infinito, superando a limitação de câmeras de foco fixo padrão;
• Compatibilidade Nativa com a Pilha Moderna libcamera: reconhecida de forma transparente pelo subsistema de captura do Raspberry Pi OS (versões Bullseye e Bookworm de 32 e 64 bits);
• Consumo Energético Otimizado: demanda apenas cerca de $250\,\text{mA}$ durante streaming contínuo em 1080p, viabilizando alimentação estável direto da porta do computador de placa única sem necessidade de fontes externas dedicadas.

Quando devo usar?

Este componente é a solução recomendada quando:

• O projeto exige equilíbrio ideal entre baixo custo, confiabilidade, boa resolução ($5\,\text{MP}$ / 1080p) e suporte maduro de software no Raspberry Pi;
• É necessário realizar ajustes precisos na distância de foco da lente para registrar alvos em distâncias específicas;
• Aplicações com bibliotecas Python (Picamera2, OpenCV) e pipelines GStreamer em Raspberry Pi 3, Pi 4, Pi 5 ou Pi Zero 2 W.

Quando não devo usar:

• Microcontroladores clássicos de 8 bits sem periférico de vídeo de alta velocidade (como o ATmega328P do Arduino Uno), pois estes chips não dispõem de transceptores diferenciais MIPI CSI-2 nem taxa de amostragem na ordem de centenas de megabits por segundo;
• Ambientes de escuridão total desprovidos de iluminação externa visível, pois a lente possui filtro IR-Cut fixo. Para monitoramento com leds infravermelhos na escuridão, deve-se adotar módulos da série NoIR.

Pinout e diagrama de entradas/saídas

O módulo de câmera estabelece comunicação física e lógica através de um conector plano FFC (Flexible Flat Cable) de 15 vias com passo de $1{,}0\,\text{mm}$. A pinagem oficial padronizada encontra-se discriminada na tabela a seguir:

Pino FFC	Nome do Terminal	Tipo de Sinal	Descrição Técnica e Função
1	GND	Referência	Retorno de terra e blindagem eletrostática
2	CAM_D0_N	Saída Dif.	MIPI CSI-2 Data Lane 0 (Polaridade Negativa)
3	CAM_D0_P	Saída Dif.	MIPI CSI-2 Data Lane 0 (Polaridade Positiva)
4	GND	Referência	Malha de terra entre vias diferenciais
5	CAM_D1_N	Saída Dif.	MIPI CSI-2 Data Lane 1 (Polaridade Negativa)
6	CAM_D1_P	Saída Dif.	MIPI CSI-2 Data Lane 1 (Polaridade Positiva)
7	GND	Referência	Malha de terra entre vias diferenciais
8	CAM_CLK_N	Saída Dif.	MIPI CSI-2 Clock Lane (Polaridade Negativa)
9	CAM_CLK_P	Saída Dif.	MIPI CSI-2 Clock Lane (Polaridade Positiva)
10	GND	Referência	Malha de terra entre vias de dados e controle
11	CAM_GPIO / PWDN	Entrada Lógica	Controle de Power-Down ($3{,}3\,\text{V}$ ativo / habilitação)
12	FREX / NC	E/S Lógica	Sincronismo de exposição de quadro (Frame Exposure / não conectado)
13	CAM_SCL	Entrada Lógica	Clock do barramento serial I2C/SCCB ($3{,}3\,\text{V}$, até $400\,\text{kHz}$)
14	CAM_SDA	Bidirecional	Linha de dados bidirecional I2C/SCCB ($3{,}3\,\text{V}$)
15	3V3	Alimentação	Entrada de alimentação regulada contínua $+3{,}3\,\text{V}$ DC

Como fazer a ligação

Requisitos de instalação e alimentação

Para assegurar a integridade dos sinais diferenciais de alta frequência e prevenir falhas irreversíveis no hardware, observe as seguintes diretrizes de montagem:

1. Desenergização Prévia Total: desligue completamente a fonte de alimentação do Raspberry Pi da tomada antes de manipular a presilha do conector ou introduzir o cabo flat. O encaixe a quente (hot-plugging) produz arcos de microdescarga eletrostática capazes de queimar as portas de entrada MIPI da GPU;
2. Orientação dos Contatos Metálicos:
   • Na extremidade conectada à câmera: os contatos metálicos prateados/dourados do cabo flat devem ficar voltados para a superfície da placa de circuito impresso da câmera;
   • Na extremidade conectada ao Raspberry Pi (Pi 3 / Pi 4): os contatos metálicos do cabo flat devem ficar voltados na direção contrária à trava preta (voltados para as portas HDMI);
3. Mecanismo de Travamento: puxe a trava preta do conector CSI suavemente para cima com as unhas até abrir o canal. Insira a ponta do cabo reto e firme até encostar no fundo do batente e, em seguida, pressione a trava preta para baixo de maneira simétrica;
4. Alívio Mecânico: não force vincos agudos nem dobre o cabo com raio inferior a $5\,\text{mm}$ para preservar a integridade das pistas condutoras internas de cobre.

Tabela de conexões dos terminais

A conexão do módulo ao barramento de vídeo é estabelecida pelo cabo plano flexível FFC de 15 vias. A relação De $\to$ Para entre o módulo OV5647 e o conector CSI do Raspberry Pi é direta via cabo paralelo conforme a tabela a seguir:

Terminal no Módulo OV5647	Pino no Conector CSI (Pi 3 / Pi 4)	Tipo de Linha	Função do Sinal	Observação Técnica
Pino 1 (GND)	Pino 1 da porta CSI	Referência	Plano de Aterramento 0V	Blindagem de borda do cabo flat
Pino 2 (CAM_D0_N)	Pino 2 da porta CSI	Dados MIPI	Via Negativa do Par D0	Par trançado diferencial de dados
Pino 3 (CAM_D0_P)	Pino 3 da porta CSI	Dados MIPI	Via Positiva do Par D0	Par trançado diferencial de dados
Pino 4 (GND)	Pino 4 da porta CSI	Referência	Plano de Aterramento 0V	Isolamento entre par D0 e D1
Pino 5 (CAM_D1_N)	Pino 5 da porta CSI	Dados MIPI	Via Negativa do Par D1	Par trançado diferencial de dados
Pino 6 (CAM_D1_P)	Pino 6 da porta CSI	Dados MIPI	Via Positiva do Par D1	Par trançado diferencial de dados
Pino 7 (GND)	Pino 7 da porta CSI	Referência	Plano de Aterramento 0V	Isolamento entre dados e clock
Pino 8 (CAM_CLK_N)	Pino 8 da porta CSI	Clock MIPI	Via Negativa do Sinal de Clock	Transmissão de clock diferencial
Pino 9 (CAM_CLK_P)	Pino 9 da porta CSI	Clock MIPI	Via Positiva do Sinal de Clock	Transmissão de clock diferencial
Pino 10 (GND)	Pino 10 da porta CSI	Referência	Plano de Aterramento 0V	Isolamento entre clock e controle
Pino 11 (PWDN)	Pino 11 da porta CSI	Controle	Habilitação do Sensor	Sinal lógico mantido alto pelo driver
Pino 12 (NC / FREX)	Pino 12 da porta CSI	Controle	Linha de Sincronismo Auxiliar	Não conectado em operação padrão
Pino 13 (CAM_SCL)	Pino 13 da porta CSI	I2C (CCI)	Clock Serial I2C / SCCB	Sincronismo do barramento de comandos
Pino 14 (CAM_SDA)	Pino 14 da porta CSI	I2C (CCI)	Dados Seriais I2C / SCCB	Leitura/escrita de registradores do sensor
Pino 15 (3V3)	Pino 15 da porta CSI	Alimentação	Tensão Contínua +3.3V DC	Suprimento de corrente para o módulo

💡 Dica: Para conexão em placas Raspberry Pi 5 ou Raspberry Pi Zero / Zero 2 W, que utilizam portas miniaturizadas de 22 vias com passo de $0{,}5\,\text{mm}$, utilize um cabo adaptador FFC híbrido (15 vias $1{,}0\,\text{mm}$ para 22 vias $0{,}5\,\text{mm}$). A ordem e função dos sinais são compatibilizadas pelo próprio adaptador.

Cuidados e observações de segurança

⛔ Perigo: Nunca conecte ou desconecte o flat cable com a placa Raspberry Pi ligada à fonte. O pino 15 conduz $+3{,}3\,\text{V}$ com capacidade de corrente contínua e localiza-se ao lado do pino de dados digitais. A inclinação diagonal durante a inserção com energia viva pode provocar curto-circuito catastrófico, inutilizando o sensor e os canais de entrada da placa controladora.

⚠️ Atenção: Os sensores CMOS são componentes altamente sensíveis a descargas eletrostáticas (ESD). Antes de manipular a placa com os dedos, encoste as mãos em uma superfície metálica devidamente aterrada ou utilize uma pulseira antiestática de bancada.

Como usar

Guia de operação passo a passo

O sistema operacional oficial Raspberry Pi OS (Debian 12 Bookworm e Debian 11 Bullseye) adota a arquitetura moderna baseada em libcamera, V4L2 e nas ferramentas de linha de comando rpicam-apps (anteriormente libcamera-apps).

Passo 1: Habilitação e Verificação no Firmware

Abra o arquivo de configuração de boot do sistema no terminal:

sudo nano /boot/firmware/config.txt

(Em sistemas legados baseados no Bullseye, utilize /boot/config.txt).

Certifique-se de que a detecção automática de câmeras está habilitada:

# Habilita deteccao automatica do subsistema de cameras
camera_auto_detect=1

Caso deseje forçar o carregamento do driver do sensor OV5647 de maneira explícita, insira o overlay correspondente:

dtoverlay=ov5647

Salve o arquivo (Ctrl + O, Enter e Ctrl + X) e reinicie o computador de placa única:

sudo reboot

Passo 2: Diagnóstico e Reconhecimento do Hardware

Após o reinício, execute o utilitário de sondagem oficial para checar se o sensor OV5647 foi detectado pelo kernel Linux:

rpicam-hello --list-cameras

A saída no terminal deve confirmar a presença do sensor com suas resoluções nativas:

Available cameras
-----------------
0 : ov5647 [2592x1944 10-bit RGGB] (/base/soc/i2c0mux/i2c@1/ov5647@36)
    Modes: 'SRGGB10_CSI2P' : 640x480 [90.00 fps - (0, 0)/2592x1944 crop]
                             1280x720 [60.00 fps - (0, 0)/2592x1944 crop]
                             1920x1080 [30.00 fps - (336, 432)/1920x1080 crop]
                             2592x1944 [15.00 fps - (0, 0)/2592x1944 crop]

Passo 3: Visualização em Tempo Real e Ajuste do Foco Óptico

Inicie a janela de pré-visualização contínua na interface desktop para efetuar a calibração física da distância focal da lente:

rpicam-hello -t 0

1. Aponte a câmera para um alvo de referência posicionado na distância de trabalho do seu projeto;
2. Gire suavemente o anel serrilhado da lente cilíndrica M12 no sentido horário ou anti-horário até que a imagem alcance nitidez máxima;
3. Aperte com cuidado o pequeno parafuso de travamento lateral na base da rosca para travar a lente e impedir que vibrações mecânicas descalibrem o foco;
4. Encerre o teste pressionando Ctrl + C no terminal.

Passo 4: Captura de Fotografia em Resolução Máxima (5MP)

Para registrar uma foto estática em resolução máxima ($2592 \times 1944$) com compressão JPEG de alta qualidade ($95\%$):

rpicam-still -o captura_5mp.jpg --width 2592 --height 1944 -t 2000 --quality 95

Passo 5: Gravação de Vídeo em Full HD (1080p a 30 fps)

Para capturar um vídeo em alta definição ($1920 \times 1080$) durante 10 segundos codificado em H.264 por hardware:

rpicam-vid -o video_teste_1080p.h264 -t 10000 --width 1920 --height 1080 --framerate 30

Modos de operação e ajustes

O sensor OmniVision OV5647 opera em diferentes configurações de recorte (crop), decimação (sub-sampling) e combinação de cargas (binning), adaptando-se às necessidades de tempo real ou fidelidade espacial da aplicação:

• Modo Resolução Total ($2592 \times 1944$ a $15\,\text{fps}$): utiliza todos os $5$ milhões de pixels do sensor para inspeção estática com máxima densidade de detalhes;
• Modo Full HD ($1920 \times 1080$ a $30\,\text{fps}$): realiza o recorte central da área ativa preservando a proporção panorâmica 16:9 em $30\,\text{fps}$ contínuos para streaming e gravação;
• Modo Alta Taxa 720p / VGA ($1280 \times 720$ a $60\,\text{fps}$ e $640 \times 480$ a $90\,\text{fps}$): decima a amostragem para entregar alta taxa temporal, ideal para rastreamento visual cinemático e navegação robótica veloz.

A taxa teórica instantânea de transmissão de dados ($R_{\text{bit}}$) no barramento serial MIPI CSI-2 para a captura em resolução total pode ser calculada através da relação:

$$R_{\text{bit}} = \frac{W \times H \times B_{\text{pixel}} \times f_{\text{quadro}}}{N_{\text{vias}}}$$

Onde:

• $W$: largura da matriz de pixels ($2592$);
• $H$: altura da matriz de pixels ($1944$);
• $B_{\text{pixel}}$: profundidade de bits do sinal bruto ($10\,\text{bits}$ no modo RAW10);
• $f_{\text{quadro}}$: frequência de amostragem ($15\,\text{fps}$);
• $N_{\text{vias}}$: número de vias diferenciais de dados ativas ($2$ vias).

Substituindo os valores nominais:

$$R_{\text{bit}} = \frac{2592 \times 1944 \times 10 \times 15}{2} \approx 377{,}9\,\text{Mbps por via}$$

A taxa calculada de $377{,}9\,\text{Mbps}$ comprova que a transmissão opera confortavelmente dentro do teto de projeto suportado pelo transceptor MIPI do sensor ($800\,\text{Mbps}$ por canal diferencial).

Exemplos práticos de uso

Exemplo 1: Processamento em Tempo Real com Python, Picamera2 e OpenCV

O script em Python a seguir demonstra como inicializar o sensor OV5647 no Raspberry Pi OS utilizando a biblioteca oficial Picamera2, capturar quadros brutos no buffer de memória e aplicar filtros morfológicos e detecção de bordas com OpenCV com medição contínua de taxa de quadros (FPS):

#!/usr/bin/env python3
"""
RoboBuilders - Processamento Visual com Camera OV5647
Compativel com Raspberry Pi 3, 4, 5 e Pi Zero 2 W (Raspberry Pi OS Bookworm)
Captura direta com Picamera2 e processamento com OpenCV
"""

import time
import cv2
from picamera2 import Picamera2

def main():
    print("[INFO] Inicializando a camera OV5647 com Picamera2...")
    picam2 = Picamera2()

    # Configuracao de preview em 1280x720 a 30 fps no formato RGB
    config = picam2.create_preview_configuration(
        main={"format": "XBGR8888", "size": (1280, 720)},
        controls={"FrameRate": 30}
    )
    picam2.configure(config)
    picam2.start()

    # Pausa para estabilizacao do algoritmo de auto-exposicao (AEC)
    time.sleep(1.0)
    print("[INFO] Camera inicializada com sucesso. Pressione 'q' na janela para encerrar.")

    tempo_anterior = time.time()
    contador_frames = 0
    taxa_fps = 0.0

    while True:
        # Aquisicao de imagem diretamente em array numpy
        frame = picam2.capture_array()

        # Conversao para tons de cinza
        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

        # Filtro de suavizacao Gaussiana para reducao de ruido de alta frequencia
        blur = cv2.GaussianBlur(gray, (5, 5), 0)

        # Extracao de bordas com detector Canny
        bordas = cv2.Canny(blur, 50, 150)

        # Calculo de FPS em tempo real
        contador_frames += 1
        tempo_atual = time.time()
        intervalo = tempo_atual - tempo_anterior
        if intervalo >= 1.0:
            taxa_fps = contador_frames / intervalo
            contador_frames = 0
            tempo_anterior = tempo_atual

        # Renderizacao de telemetria sobre o quadro
        cv2.putText(
            frame,
            f"Sensor: OmniVision OV5647 5MP | FPS: {taxa_fps:.1f}",
            (20, 40),
            cv2.FONT_HERSHEY_SIMPLEX,
            0.8,
            (0, 255, 0),
            2,
            cv2.LINE_AA
        )

        # Exibicao das janelas de saida
        cv2.imshow("RoboBuilders - Stream Original OV5647", frame)
        cv2.imshow("RoboBuilders - Detector Canny (Bordas)", bordas)

        # Interrupcao ao pressionar 'q'
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break

    # Finalizacao limpa dos recursos de hardware
    print("[INFO] Finalizando captura...")
    picam2.stop()
    cv2.destroyAllWindows()

if __name__ == "__main__":
    main()

Exemplo 2: Código C++ para Diagnóstico do Barramento I2C / SCCB (Arduino / ESP32)

O barramento de controle serial do sensor OV5647 obedece ao protocolo SCCB (Serial Camera Control Bus), compatível com I2C em $3{,}3\,\text{V}$ no endereço de 7 bits 0x36. Em bancadas de teste, validação de chicotes ou projetos avançados com microcontroladores (como placas de teste ESP32 ou depuradores I2C), o firmware em C++ a seguir lê os registradores internos de 16 bits 0x300A e 0x300B, que contêm a identificação indelével do fabricante: 0x56 e 0x47 (código 0x5647):

/**
 * ============================================================================
 * RoboBuilders - Diagnostico de Hardware I2C / SCCB do Sensor OmniVision OV5647
 * Valida a integridade do barramento de controle, niveis de tensao e conexao
 * Registradores de Modelo: 0x300A (High Byte = 0x56) e 0x300B (Low Byte = 0x47)
 * Plataformas: Arduino (com conversor 3.3V) / ESP32 / STM32
 * ============================================================================
 */

#include <Arduino.h>
#include <Wire.h>

// Endereco I2C de 7 bits padrao da camera OV5647
#define OV5647_I2C_ADDR       0x36

// Registradores internos de identificacao do chip (16 bits)
#define OV5647_REG_CHIP_ID_H  0x300A
#define OV5647_REG_CHIP_ID_L  0x300B

/**
 * Funcao para ler um byte a partir de um registrador interno com endereco de 16 bits
 */
int lerRegistrador16(uint8_t enderecoI2C, uint16_t registrador) {
  Wire.beginTransmission(enderecoI2C);
  Wire.write((uint8_t)(registrador >> 8));    // Byte mais significativo do endereco
  Wire.write((uint8_t)(registrador & 0xFF));  // Byte menos significativo do endereco
  if (Wire.endTransmission(false) != 0) {
    return -1; // Falha de transmissao no barramento
  }

  Wire.requestFrom(enderecoI2C, (uint8_t)1);
  if (Wire.available()) {
    return Wire.read();
  }
  return -1;
}

void setup() {
  Serial.begin(115200);
  while (!Serial && millis() < 3000); // Aguarda conexao do monitor serial

  Serial.println(F("===================================================="));
  Serial.println(F("RoboBuilders - Teste de Diagnostico I2C OV5647 5MP"));
  Serial.println(F("===================================================="));

  // Inicializacao do barramento I2C em 100 kHz (Standard Mode)
  Wire.begin();
  Wire.setClock(100000);

  delay(200); // Tempo para estabilizacao da tensao de 3.3V no sensor

  Serial.print(F("[INFO] Sondando dispositivo no endereco I2C 0x"));
  Serial.println(OV5647_I2C_ADDR, HEX);

  // Leitura sequencial dos bytes do Chip ID
  int idHigh = lerRegistrador16(OV5647_I2C_ADDR, OV5647_REG_CHIP_ID_H);
  int idLow  = lerRegistrador16(OV5647_I2C_ADDR, OV5647_REG_CHIP_ID_L);

  if (idHigh >= 0 && idLow >= 0) {
    uint16_t chipID = ((uint16_t)idHigh << 8) | (uint8_t)idLow;

    Serial.print(F("[SUCESSO] Sensor detectado! Chip ID lido: 0x"));
    if (chipID < 0x1000) Serial.print(F("0"));
    Serial.println(chipID, HEX);

    if (chipID == 0x5647) {
      Serial.println(F("[CONFIRMADO] Hardware compativel: OmniVision OV5647 (5 Megapixels)."));
      Serial.println(F("[STATUS] Barramento serial I2C e linhas de alimentacao operacionais."));
    } else {
      Serial.println(F("[AVISO] Dispositivo respondeu, mas o ID difere do padrao 0x5647."));
    }
  } else {
    Serial.println(F("[FALHA] Nao foi possivel comunicar com o sensor OV5647."));
    Serial.println(F("[VERIFICAR] Confira a tensao de 3.3V, terra comum e resistores pull-up de 4.7k."));
  }
}

void loop() {
  // Loop ocioso apos conclusao da rotina de teste
  delay(5000);
}

Conclusão

Neste manual técnico, foram apresentadas todas as etapas para implementação e operação da Câmera Raspberry Pi OV5647 5MP 1080p 3.6mm:

• Arquitetura e Óptica: matriz de pixels retroiluminada OmniVision OV5647 de $5\,\text{MP}$ combinada com conjunto de lentes ajustáveis M12 de $3{,}6\,\text{mm}$ e campo de visão diagonal de $60^\circ$;
• Limites e Características Elétricas: suprimento regulado de $3{,}3\,\text{V}$ com consumo típico de $250\,\text{mA}$, interface de vídeo de alta velocidade MIPI CSI-2 e barramento de controle serial I2C/SCCB;
• Instalação Física e Mecânica: montagem segura do flat cable FFC de 15 vias ($1{,}0\,\text{mm}$) no conector CSI, procedimento de alívio mecânico e técnica de foco manual fino;
• Operação no Raspberry Pi OS: utilização das ferramentas de linha de comando rpicam-hello, rpicam-still e rpicam-vid na pilha moderna libcamera;
• Desenvolvimento de Software: exemplos validados de captura em tempo real com Picamera2/OpenCV em Python e rotina de validação e diagnóstico de registradores em C++.

Solução de problemas

Olá! Sou o assistente técnico da RoboBuilders. Descreva seu problema com o Câmera Raspberry Pi OV5647 5MP 1080p 3.6mm: Manual Técnico Completo e eu ajudarei a encontrar a solução.

Enviar

O assistente usa IA e pode errar. Confirme informações críticas no datasheet oficial do fabricante.