Câmera Raspberry Pi V1.3: Manual Técnico Completo

Introdução

Neste manual, será apresentado como instalar, configurar e utilizar a Câmera Raspberry Pi V1.3. Se desejar adquirir este produto, clique aqui.

Projetada ao redor do sensor de imagem CMOS OmniVision OV5647 de arquitetura QSXGA ($2592 \times 1944$ pixels), a Câmera Raspberry Pi Rev 1.3 (V1.3) fornece captura fotográfica nativa de $5\,\text{MP}$ e gravação de fluxos de vídeo em alta definição Full HD 1080p a $30\,\text{fps}$ (ou até $90\,\text{fps}$ em resolução VGA). Sua construção ultracompacta de $25\,\text{mm} \times 24\,\text{mm}$ integra um conjunto óptico colimado de foco fixo ($1\,\text{m}$ até o infinito) com abertura $f/2{,}9$ e comunicação direta via barramento diferencial de alta velocidade MIPI CSI-2 (Camera Serial Interface), permitindo processamento de imagem acelerado por hardware na GPU/ISP sem sobrecarregar a CPU principal do sistema embarcado.

Este documento técnico reúne os parâmetros ópticos, limites elétricos do regulador interno de $3{,}3\,\text{V}$, mapeamento completo do conector plano flexível (FFC) de 15 vias, protocolos de controle de registradores via barramento serial SCCB / I2C (endereço 0x36), procedimentos de comissionamento na pilha libcamera (rpicam-apps) e códigos completos em Python e C++ (Arduino / ESP32) para operação e diagnóstico de bancada.

Especificações técnicas

O módulo combina o transdutor óptico CMOS OmniVision OV5647 (montado em soquete mezzanine tipo SUNNY), reguladores lineares Low-Dropout (LDO) para geração das tensões internas do núcleo analógico e digital, oscilador de cristal dedicado e interface para cabo plano flexível FFC de 15 vias com passo (pitch) de $1{,}0\,\text{mm}$.

Principais especificações

A tabela a seguir detalha as características ópticas, geométricas e de processamento de vídeo da revisão 1.3 do módulo:

Parâmetro	Especificação Técnica
Modelo / Revisão da Placa	Raspberry Pi Camera Board Rev 1.3 (SKU RB0084)
Sensor de Imagem	OmniVision OV5647 Color CMOS QSXGA ($5\,\text{Megapixels}$)
Tamanho Óptico do Sensor	Formato $1/4^{\prime\prime}$ ($3{,}67\,\text{mm} \times 2{,}74\,\text{mm}$, diagonal de $4{,}58\,\text{mm}$)
Resolução Ativa da Matriz	$2592 \times 1944$ pixels ($5{,}038\,\text{MP}$)
Dimensão Física do Pixel	$1{,}4\,\mu\text{m} \times 1{,}4\,\mu\text{m}$ (Tecnologia OmniBSI™ retroiluminada)
Distância Focal da Lente ($f$)	$3{,}60\,\text{mm}$ (equivalente a $35\,\text{mm}$ em câmera Full-Frame SLR)
Abertura Relativa (F-number)	$f/2{,}9$
Sistema de Focalização	Foco fixo colimado de fábrica ($1\,\text{m}$ até o infinito)
Ângulo de Visão (FOV Horizontal $\times$ Vertical)	$54^\circ \times 41^\circ$ (aproximadamente $65^\circ$ diagonal)
Campo de Visão Linear a $2\,\text{m}$	$2{,}00\,\text{m} \times 1{,}33\,\text{m}$
Filtro Óptico Integrado	Filtro de corte infravermelho (IR-Cut) em $650\,\text{nm} \pm 10\,\text{nm}$
Modos e Taxas de Quadro de Vídeo	$1920 \times 1080$ (1080p) @ $30\,\text{fps}$ $1280 \times 720$ (720p) @ $60\,\text{fps}$ $640 \times 480$ (VGA) @ $60\,\text{fps}$ / $90\,\text{fps}$
Formatos de Saída Bruta do Sensor	8-bit / 10-bit RAW RGB (Padrão de filtro de cor Bayer)
Interface de Transmissão de Vídeo	MIPI CSI-2 de 2 vias de dados (2 Data Lanes) + 1 via de clock
Interface de Controle e Configuração	Barramento serial SCCB compatível com I2C (até $400\,\text{kHz}$)
Endereço I2C Padrão (7 bits)	0x36 (0x6C escrita / 0x6D leitura em formato 8 bits)
Conector Físico	FFC/FPC de 15 vias com trava deslizante, passo de $1{,}0\,\text{mm}$
Dimensões da Placa PCB	$25{,}0\,\text{mm} \times 24{,}0\,\text{mm} \times 9{,}0\,\text{mm}$ (sem o cabo flat)
Massa Aproximada	$3\,\text{g}$ (apenas o módulo PCB + lente)

Características elétricas e operacionais

A placa recebe alimentação regulada de $+3{,}3\,\text{V}$ DC através do pino 15 do barramento CSI e sintetiza internamente os barramentos de tensão necessários para o arranjo de fotodiodos ($2{,}8\,\text{V}$ analógico) e para a lógica de conversão e serialização MIPI ($1{,}5\,\text{V}$ digital):

Grandeza Elétrica / Operacional	Mínimo	Típico	Máximo	Unidade
Tensão de Alimentação Principal ($\text{VCC}$ / Pino 15)	$3{,}00$	$3{,}30$	$3{,}60$	$\text{V}$
Tensão Analógica Interna do Sensor ($V_{\text{AVDD}}$)	$2{,}60$	$2{,}80$	$3{,}00$	$\text{V}$
Tensão do Núcleo Digital Interno ($V_{\text{DVDD}}$)	$1{,}42$	$1{,}50$	$1{,}58$	$\text{V}$
Tensão Lógica de Interface I/O ($V_{\text{DOVDD}}$)	$1{,}70$	$3{,}30$	$3{,}45$	$\text{V}$
Corrente de Operação Ativa (Captura 1080p30)	$180$	$250$	$290$	$\text{mA}$
Corrente em Modo Standby / Power-Down (PWDN = LOW)	—	$20$	$60$	$\mu\text{A}$
Nível Lógico Alto no Barramento I2C/SCCB ($V_{\text{IH}}$)	$2{,}31$	$3{,}30$	$3{,}60$	$\text{V}$
Nível Lógico Baixo no Barramento I2C/SCCB ($V_{\text{IL}}$)	$-0{,}30$	$0{,}00$	$0{,}99$	$\text{V}$
**Excursão Diferencial MIPI High-Speed ($	V_{\text{OD}}	$)**	$140$	$200$
Tensão de Modo Comum MIPI High-Speed ($V_{\text{CMTX}}$)	$150$	$200$	$250$	$\text{mV}$
Impedância Diferencial das Pistas MIPI ($Z_{\text{diff}}$)	$90$	$100$	$110$	$\Omega$
Relação Sinal-Ruído Máxima ($\text{SNR}_{\text{máx}}$)	—	$36$	—	$\text{dB}$
Faixa Dinâmica Óptica (Dynamic Range)	—	$68$	—	$\text{dB}$
Temperatura de Operação Ambiente	$-20$	$+25$	$+70$	$^\circ\text{C}$
Faixa Térmica de Estabilidade Óptica	$0$	$+25$	$+50$	$^\circ\text{C}$

⚠️ Atenção: Os pinos de controle digital (CAM_SCL, CAM_SDA e CAM_GPIO) operam exclusivamente com lógica de $3{,}3\,\text{V}$ e não são tolerantes a $5\,\text{V}$. Ao realizar diagnósticos do barramento I2C/SCCB com microcontroladores de $5\,\text{V}$ (como o Arduino Uno/Mega), é obrigatório utilizar um conversor de nível lógico bidirecional (Level Shifter), sob pena de destruição imediata das portas do sensor OV5647.

Descrição do produto

O que é a Câmera Raspberry Pi V1.3?

A Câmera Raspberry Pi V1.3 (Rev 1.3) é o módulo de captura óptica padrão de primeira geração projetado especificamente para conexão direta à porta CSI (Camera Serial Interface) dos computadores de placa única Raspberry Pi. Seu elemento sensor ativo é o chip CMOS colorido OmniVision OV5647, organizado em uma matriz de $2592 \times 1944$ pixels com tecnologia de iluminação traseira (Back-Side Illumination — OmniBSI™), que posiciona as camadas metálicas de roteamento abaixo dos fotodiodos para elevar a sensibilidade quântica e reduzir o acoplamento cruzado óptico (crosstalk) entre pixels adjacentes de $1{,}4\,\mu\text{m}$.

Diferentemente de webcams convencionais conectadas via barramento USB — que dependem de conversão de protocolo e consomem ciclos expressivos de CPU —, a revisão 1.3 transfere os quadros digitais em formato bruto Bayer RAW de 8 ou 10 bits através de dois pares diferenciais de sinalização de baixa tensão (MIPI CSI-2) diretamente para o coprocessador gráfico VideoCore/ISP da placa hospedeira. O controle de exposição eletrônica (rolling shutter), ganho analógico, calibração de nível de preto (BLC) e seleção de resolução é gerenciado de forma independente pelo barramento serial de dois fios SCCB/I2C no endereço fixo 0x36.

Para que serve?

O módulo atende a projetos de engenharia embarcada e automação que demandam aquisição de imagens com baixa latência e dimensões reduzidas:

• Visão Computacional e Robótica Autônoma: processamento de quadros em tempo real com OpenCV e Picamera2 para navegação de robôs móveis, leitura de marcadores fiduciais (ArUco/QR Code), classificação de cores e detecção de objetos;
• Monitoramento Remoto e Telemetria Visual: transmissão de vídeo em 1080p a $30\,\text{fps}$ codificado em H.264 por hardware para servidores RTSP/WebRTC, supervisão de impressoras 3D (OctoPrint/Klipper) e sistemas de segurança;
• Registro Científico e Time-Lapse Automatizado: captura programada de fotografias estáticas em resolução nativa de $5\,\text{MP}$ ($2592 \times 1944$) para acompanhamento de experimentos laboratoriais, estufas agrícolas e meteorologia.

Por que devo usar?

• Comunicação Direta MIPI CSI-2 de Baixíssima Latência: a conexão dedicada com o processador de sinal de imagem (ISP) do SoC permite codificar fluxos Full HD 1080p a $30\,\text{fps}$ com ocupação de CPU inferior a $5\%$;
• Óptica Colimada de Foco Fixo e Peso Ultraleve ($3\,\text{g}$): a ausência de conjuntos mecânicos pesados torna a placa imune a descalibração por vibração em drones, gimbals e pequenos chassis robóticos;
• Suporte Nativo Consolidado no Ecossistema Linux: compatibilidade direta com os drivers de kernel ov5647 V4L2, a pilha moderna libcamera / rpicam-apps e a biblioteca oficial Picamera2 em Python.

Quando devo usar?

Este módulo é indicado quando:

• O projeto utiliza placas Raspberry Pi (Pi 1, Pi 2, Pi 3, Pi 4, Pi 5 ou linha Pi Zero) e requer captura em 1080p ou fotos de $5\,\text{MP}$ com excelente relação custo-benefício;
• Os objetos monitorados encontram-se a distâncias a partir de $1\,\text{m}$ (ou $0{,}5\,\text{m}$ com boa iluminação), aproveitando a profundidade de campo hiperfocal da lente de $3{,}6\,\text{mm}$ ($f/2{,}9$);
• Há restrição severa de espaço físico e massa no cabeçote do equipamento ou robô.

Quando não devo usar:

• Inspeção macro a curtíssima distância (menos de $30\,\text{cm}$) sem ajuste mecânico: como a lente da versão V1.3 vem colada de fábrica para foco hiperfocal ($1\,\text{m}$ ao infinito), objetos muito próximos ficarão fora de foco, a menos que se rompa cuidadosamente o ponto de trava da rosca ou se utilize a versão OV5647 com lente M12 ajustável;
• Monitoramento noturno sob iluminação infravermelha ($850\,\text{nm} / 940\,\text{nm}$): o módulo V1.3 padrão possui filtro óptico IR-Cut integrado sobre o sensor. Para visão noturna com refletores IR, utilize a variante Pi NoIR;
• Captura direta de vídeo com microcontroladores de 8/32 bits sem interface CSI: placas como Arduino Uno, Nano ou ESP32 convencional não possuem receptor diferencial MIPI CSI-2 de alta frequência. Para captura de imagem direta em microcontroladores sem Linux embarcado, utilize o módulo ESP32-CAM (OV2640) com barramento paralelo DVP.

Pinout e diagrama de entradas/saídas

A interface elétrica da Câmera Raspberry Pi V1.3 é composta por um conector plano FFC (Flexible Flat Cable) de 15 terminais com espaçamento de $1{,}0\,\text{mm}$. A tabela abaixo descreve a função individual de cada pino, os níveis de tensão e a direção do fluxo de sinal:

Pino FFC	Nome do Sinal	Direção (Câmera $\leftrightarrow$ Host)	Nível Elétrico	Função e Descrição Técnica
1	GND	Referência	$0\,\text{V}$	Terra comum e blindagem lateral do cabo flat
2	CAM_D0_N	Saída (Câmera $\to$ Host)	MIPI ($\sim 200\,\text{mV}$)	Via de Dados Diferencial 0 — Polaridade Negativa
3	CAM_D0_P	Saída (Câmera $\to$ Host)	MIPI ($\sim 200\,\text{mV}$)	Via de Dados Diferencial 0 — Polaridade Positiva
4	GND	Referência	$0\,\text{V}$	Malha de isolamento entre o par D0 e o par D1
5	CAM_D1_N	Saída (Câmera $\to$ Host)	MIPI ($\sim 200\,\text{mV}$)	Via de Dados Diferencial 1 — Polaridade Negativa
6	CAM_D1_P	Saída (Câmera $\to$ Host)	MIPI ($\sim 200\,\text{mV}$)	Via de Dados Diferencial 1 — Polaridade Positiva
7	GND	Referência	$0\,\text{V}$	Malha de isolamento entre o par D1 e o par CLK
8	CAM_CLK_N	Saída (Câmera $\to$ Host)	MIPI ($\sim 200\,\text{mV}$)	Via de Clock Diferencial MIPI — Polaridade Negativa
9	CAM_CLK_P	Saída (Câmera $\to$ Host)	MIPI ($\sim 200\,\text{mV}$)	Via de Clock Diferencial MIPI — Polaridade Positiva
10	GND	Referência	$0\,\text{V}$	Malha de isolamento entre sinais MIPI e sinais lógicos
11	CAM_GPIO (PWDN/EN)	Entrada (Host $\to$ Câmera)	LVCMOS $3{,}3\,\text{V}$	Habilitação do regulador/sensor e oscilador (HIGH = Ativo)
12	CAM_CLK / LED_EN	Entrada (Host $\to$ Câmera)	LVCMOS $3{,}3\,\text{V}$	Controle do LED indicador frontal (Rev 1.3) ou linha auxiliar
13	CAM_SCL	Entrada (Host $\to$ Câmera)	LVCMOS $3{,}3\,\text{V}$	Clock do barramento serial de controle I2C / SCCB
14	CAM_SDA	Bidirecional	LVCMOS $3{,}3\,\text{V}$	Dados bidirecionais do barramento serial I2C / SCCB
15	VCC (+3V3)	Alimentação	$+3{,}3\,\text{V}$ DC	Entrada de tensão regulada principal (consumo até $290\,\text{mA}$)

Como fazer a ligação

Requisitos de instalação e alimentação

A correta instalação física e elétrica do módulo exige atenção aos seguintes requisitos de engenharia:

1. Fonte de Alimentação do Sistema Host: embora a câmera consuma cerca de $250\,\text{mA}$ na linha de $3{,}3\,\text{V}$, a ativação simultânea do sensor e dos blocos de codificação de vídeo na GPU eleva a corrente exigida na entrada de $5\,\text{V}$ do Raspberry Pi em até $400\,\text{mA}$. Utilize sempre uma fonte chaveada estabilizada de $5\,\text{V}$ com capacidade mínima de $2{,}5\,\text{A}$ (Pi 3B+) ou $3{,}0\,\text{A}$ (Pi 4 / Pi 5);
2. Orientação Correta do Cabo FFC de 15 Vias:
   • No conector da Câmera V1.3: os terminais metálicos expostos do cabo flat devem ficar voltados para a face da placa de circuito impresso verde (a fita azul de reforço fica voltada para fora/trás);
   • No conector CSI do Raspberry Pi (Modelos B / B+ / 2B / 3B / 3B+ / 4B): o slot CSI localiza-se entre a porta HDMI e o conector de áudio P2. Os contatos metálicos prateados devem ficar voltados para o lado das portas HDMI, e a fita azul voltada para a porta de áudio/Ethernet;
3. Adaptador para Placas com Conector Miniaturizado (22 Vias): placas Raspberry Pi Zero / Zero W / Zero 2 W e Raspberry Pi 5 utilizam conectores FPC de 22 vias com passo de $0{,}5\,\text{mm}$. Nesses modelos, substitua o cabo padrão de 15 vias ($1{,}0\,\text{mm}$) por um cabo adaptador específico de 15 vias ($1{,}0\,\text{mm}$) para 22 vias ($0{,}5\,\text{mm}$).

Diagrama de ligação elétrica

O diagrama técnico a seguir apresenta a arquitetura de interconexão em blocos da Câmera Raspberry Pi V1.3, destacando o acoplamento do cabo FFC de 15 vias ao conector CSI, os pares diferenciais MIPI CSI-2, o barramento de controle I2C/SCCB e a distribuição de alimentação:

Tabela de conexões dos terminais

A ligação entre a Câmera Raspberry Pi V1.3 e a placa controladora ocorre pino a pino por meio do cabo flat FFC de 15 vias (ou via barramento I2C de $3{,}3\,\text{V}$ em bancadas de diagnóstico com ESP32/Arduino):

Terminal de Origem (Câmera V1.3)	Terminal de Destino (Conector CSI Raspberry Pi)	Destino Alternativo (Diagnóstico I2C ESP32)	Tipo de Sinal	Observação Técnica
Pino 15 (VCC +3V3)	Pino 15 do Conector CSI	Pino 3V3 do ESP32	Alimentação DC ($+3{,}3\,\text{V}$)	Alimentação primária regulada da placa
Pinos 1, 4, 7, 10 (GND)	Pinos 1, 4, 7, 10 do Conector CSI	Pino GND do ESP32	Terra Comum ($0\,\text{V}$)	Referência elétrica e blindagem entre pares MIPI
Pino 13 (CAM_SCL)	Pino 13 do Conector CSI (I2C0_SCL)	Pino GPIO 22 (SCL) c/ pull-up $4{,}7\,\text{k}\Omega$	Clock Serial I2C ($3{,}3\,\text{V}$)	Barramento de controle SCCB até $400\,\text{kHz}$
Pino 14 (CAM_SDA)	Pino 14 do Conector CSI (I2C0_SDA)	Pino GPIO 21 (SDA) c/ pull-up $4{,}7\,\text{k}\Omega$	Dados Seriais I2C ($3{,}3\,\text{V}$)	Endereço escravo de 7 bits fixo em 0x36
Pino 11 (CAM_GPIO)	Pino 11 do Conector CSI	Pino GPIO 4 (ou pull-up p/ 3V3)	Controle Digital ($3{,}3\,\text{V}$)	Nível HIGH ($3{,}3\,\text{V}$) ativa o LDO e o clock da placa
Pino 12 (CAM_CLK/LED)	Pino 12 do Conector CSI	Deixar sem conexão (NC)	Controle Auxiliar ($3{,}3\,\text{V}$)	Acionamento do LED frontal na revisão 1.3
Pinos 2 e 3 (D0_N / D0_P)	Pinos 2 e 3 do Conector CSI	Exclusivo para Host MIPI CSI-2	Par Diferencial MIPI D0	Canal 0 de vídeo serial de alta velocidade
Pinos 5 e 6 (D1_N / D1_P)	Pinos 5 e 6 do Conector CSI	Exclusivo para Host MIPI CSI-2	Par Diferencial MIPI D1	Canal 1 de vídeo serial de alta velocidade
Pinos 8 e 9 (CLK_N / CLK_P)	Pinos 8 e 9 do Conector CSI	Exclusivo para Host MIPI CSI-2	Par Diferencial MIPI CLK	Clock síncrono de amostragem DDR MIPI CSI-2

Cuidados e observações de segurança

⛔ Perigo: Jamais insira ou remova o cabo flat FFC com a placa Raspberry Pi energizada (hot-plugging é estritamente proibido). Como o pino 15 transporta $+3{,}3\,\text{V}$ na borda do conector, uma leve inclinação angular durante o encaixe com o sistema ligado causa curto-circuito direto entre a linha de alimentação e o barramento I2C ou terra, queimando instantaneamente o sensor OV5647 e o barramento CSI do processador.

⚠️ Atenção: O subconjunto óptico central é conectado à PCB verde por um pequeno conector mezzanine flexível amarelo identificável pela inscrição SUNNY. Durante o manuseio ou fixação com parafusos M2, pressione suavemente o topo plano desse conector para garantir que o transporte não o tenha desencaixado, e remova a película plástica protetora da lente antes de iniciar as capturas.

💡 Dica: Mantenha o cabo FFC afastado de fontes chaveadas abertas, motores de corrente contínua e inversores PWM. O acoplamento indutivo de ruído eletromagnético sobre o cabo flat sem blindagem metálica externa pode corromper pacotes CRC no barramento MIPI CSI-2 e gerar falhas de timeout de quadro.

Como usar

Guia de operação passo a passo

Nas distribuições atuais do Raspberry Pi OS (Debian 12 Bookworm e Debian 11 Bullseye), o acesso ao módulo OV5647 é gerenciado pela pilha de código aberto libcamera em conjunto com os utilitários rpicam-apps.

Passo 1: Configuração do Device Tree no Firmware de Boot

Com a câmera devidamente conectada à porta CSI (e o sistema ligado após o encaixe), abra o terminal do Raspberry Pi e edite o arquivo de configuração de inicialização:

sudo nano /boot/firmware/config.txt

(Nota: em instalações anteriores baseadas no Debian Bullseye, o caminho do arquivo é /boot/config.txt).

Verifique se a diretiva de detecção automática de câmeras CSI está ativa (1). Caso utilize cabos adaptadores ou deseje declarar explicitamente o driver do sensor OV5647, garanta a seguinte configuração:

# Habilita a varredura automatica de sensores MIPI CSI-2 no barramento I2C
camera_auto_detect=1

# Opcional: caso camera_auto_detect esteja como 0, descomente a linha abaixo:
# dtoverlay=ov5647

Salve as alterações (Ctrl + O, Enter e Ctrl + X) e reinicie o sistema operacional:

sudo reboot

Passo 2: Enumeração e Validação do Sensor no Kernel

Após a reinicialização, execute o comando de listagem para confirmar que o driver V4L2 comunicou com o endereço I2C 0x36 e reconheceu a matriz OV5647:

rpicam-hello --list-cameras

A saída padrão exibirá o identificador do chip e as quatro geometrias de amostragem nativas em 10 bits (SRGGB10_CSI2P):

Available cameras
-----------------
0 : ov5647 [2592x1944 10-bit RGGB] (/base/soc/i2c0mux/i2c@1/ov5647@36)
    Modes: 'SRGGB10_CSI2P' : 640x480 [58.92 fps - (16, 0)/2560x1920 crop]
                             1296x972 [46.34 fps - (0, 0)/2592x1944 crop]
                             1920x1080 [32.81 fps - (348, 434)/1928x1080 crop]
                             2592x1944 [15.63 fps - (0, 0)/2592x1944 crop]

Passo 3: Teste de Pré-Visualização e Captura Fotográfica (5MP)

Para abrir uma janela de vídeo em tempo real durante $5\,\text{segundos}$ e validar o enquadramento:

rpicam-hello -t 5000

Para capturar uma fotografia estática na resolução máxima do sensor ($2592 \times 1944$ pixels) após $2\,\text{segundos}$ de estabilização do controle automático de exposição (AEC) e ganho (AGC):

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

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

Para gravar $10\,\text{segundos}$ de vídeo em alta definição ($1920 \times 1080$ a $30\,\text{fps}$) utilizando o codificador H.264 por hardware:

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

Modos de operação e ajustes

O sensor OmniVision OV5647 dispõe de modos internos de leitura completa, recorte de janela (window cropping) e combinação de pixels adjacentes (2x2 binning):

• Modo QSXGA Completo ($2592 \times 1944$ @ $15\,\text{fps}$): lê integralmente a matriz ativa de $3{,}67\,\text{mm} \times 2{,}74\,\text{mm}$ em proporção 4:3, entregando o campo de visão máximo de $54^\circ \times 41^\circ$;
• Modo Binning 2x2 ($1296 \times 972$ @ $46\,\text{fps}$): combina pares de pixels para dobrar a relação sinal-ruído em ambientes de baixa luminosidade mantendo o campo de visão integral (sem corte de bordas);
• Modo Full HD 1080p ($1920 \times 1080$ @ $30\,\text{fps}$): aplica um recorte central (crop) na matriz de pixels para evitar artefatos de interpolação escalar, resultando em um campo de visão mais fechado e focado no centro óptico.

Cálculo Óptico do Campo de Visão Linear e Distância Hiperfocal

A largura horizontal real ($L_{\text{H}}$) e a altura vertical ($L_{\text{V}}$) da cena enquadrada a uma distância de trabalho $D$ da lente (com distância focal $f = 3{,}60\,\text{mm}$ e dimensões ativas do sensor $W_{\text{s}} = 3{,}67\,\text{mm}$ e $H_{\text{s}} = 2{,}74\,\text{mm}$) são determinadas por semelhança geométrica:

$$L_{\text{H}} = D \cdot \frac{W_{\text{s}}}{f} \quad \text{e} \quad L_{\text{V}} = D \cdot \frac{H_{\text{s}}}{f}$$

Para um objeto posicionado a $D = 2{,}00\,\text{m}$ de distância da câmera no modo 4:3 completo:

$$L_{\text{H}} = 2{,}00 \cdot \frac{3{,}67}{3{,}60} \approx 2{,}04\,\text{m} \quad \text{e} \quad L_{\text{V}} = 2{,}00 \cdot \frac{2{,}74}{3{,}60} \approx 1{,}52\,\text{m}$$

Por sua vez, a distância hiperfocal ($H_{\text{f}}$) do conjunto óptico — considerando comprimento focal $f = 3{,}60\,\text{mm}$, abertura relativa $N = 2{,}9$ e círculo de confusão admissível igual a $2\times$ o passo de pixel ($c = 2{,}8\,\mu\text{m} = 0{,}0028\,\text{mm}$) — é calculada por:

$$H_{\text{f}} = \frac{f^2}{N \cdot c} + f = \frac{(3{,}60)^2}{2{,}9 \times 0{,}0028} + 3{,}60 \approx 1599{,}6\,\text{mm} \approx 1{,}60\,\text{m}$$

Com a lente colimada de fábrica próxima a $H_{\text{f}}$, todos os planos situados desde a metade da distância hiperfocal ($\sim 0{,}80\,\text{m}$ a $1{,}00\,\text{m}$) até o infinito ($\infty$) permanecem simultaneamente nítidos sem necessidade de atuador de foco automático.

Exemplos práticos de uso

Exemplo 1: Aquisição e Detecção de Objetos com Python (Picamera2 + OpenCV)

O código abaixo utiliza a biblioteca oficial Picamera2 no Raspberry Pi OS para capturar quadros diretamente em arrays NumPy, calcular a luminosidade média da cena e destacar contornos em tempo real com OpenCV:

#!/usr/bin/env python3
"""
RoboBuilders - Captura e Visao Computacional com Camera Raspberry Pi V1.3 (OV5647)
Compativel com Raspberry Pi OS (Bookworm / Bullseye) usando Picamera2 e OpenCV
"""

import time
import cv2
import numpy as np
from picamera2 import Picamera2

def main():
    # Instancia o controlador da camera na pilha libcamera
    picam2 = Picamera2()

    # Configura resolucao 1296x972 (Modo Binning 2x2 com FOV completo) a 30 FPS
    config = picam2.create_preview_configuration(
        main={"format": "RGB888", "size": (1296, 972)},
        controls={"FrameRate": 30.0, "AeEnable": True, "AwbEnable": True}
    )
    picam2.configure(config)
    picam2.start()

    # Aguarda convergencia dos algoritmos de Auto-Exposure (AEC) e Auto-White-Balance (AWB)
    time.sleep(1.0)
    print("[INFO] Camera Raspberry Pi V1.3 ativa. Pressione 'q' para encerrar.")

    t_anterior = time.perf_counter()
    fps = 0.0

    try:
        while True:
            # Captura o quadro atual diretamente como matriz NumPy (BGR para o OpenCV)
            quadro_rgb = picam2.capture_array("main")
            quadro_bgr = cv2.cvtColor(quadro_rgb, cv2.COLOR_RGB2BGR)

            # Converte para escala de cinza e calcula luminancia media
            cinza = cv2.cvtColor(quadro_bgr, cv2.COLOR_BGR2GRAY)
            luminancia_media = float(np.mean(cinza))

            # Suavizacao Gaussiana e deteccao de bordas Canny
            suavizado = cv2.GaussianBlur(cinza, (5, 5), 0)
            bordas = cv2.Canny(suavizado, 60, 160)

            # Calcula a taxa de quadros instantanea (FPS)
            t_atual = time.perf_counter()
            dt = t_atual - t_anterior
            t_anterior = t_atual
            if dt > 0:
                fps = 0.9 * fps + 0.1 * (1.0 / dt) if fps > 0 else (1.0 / dt)

            # Sobrepoe telemetria tecnica no quadro principal
            texto_hud = f"OV5647 V1.3 | {fps:.1f} FPS | Lum: {luminancia_media:.1f}"
            cv2.putText(
                quadro_bgr, texto_hud, (20, 40),
                cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 255, 0), 2, cv2.LINE_AA
            )

            # Exibe o fluxo colorido e o mapa de bordas
            cv2.imshow("RoboBuilders - Camera V1.3 (Stream)", quadro_bgr)
            cv2.imshow("RoboBuilders - Bordas Canny", bordas)

            if cv2.waitKey(1) & 0xFF == ord("q"):
                break
    finally:
        picam2.stop()
        cv2.destroyAllWindows()
        print("[INFO] Captura finalizada com seguranca.")

if __name__ == "__main__":
    main()

Exemplo 2: Firmware C++ para Diagnóstico de Bancada e Configuração I2C/SCCB (Arduino / ESP32)

Em bancadas de engenharia, manutenção de módulos ou projetos em que um microcontrolador ESP32 ou Arduino ($3{,}3\,\text{V}$) atua como mestre de diagnóstico e controle dos registradores internos do sensor OmniVision OV5647 (via barramento Wire I2C no endereço de 7 bits 0x36), o código C++ completo a seguir realiza:

1. O acionamento da linha de habilitação CAM_GPIO (Pino 11 do FFC);
2. A varredura do barramento I2C e verificação do Chip ID de 16 bits nos registradores 0x300A (esperado 0x56) e 0x300B (esperado 0x47);
3. A leitura e escrita de registradores de controle de exposição, ganho e ativação do gerador interno de padrão de barras de cor (Color Bar Test Pattern no registrador 0x503D).

/**
 * ============================================================================
 * RoboBuilders - Firmware de Diagnostico e Controle I2C/SCCB para Camera V1.3
 * Sensor: OmniVision OV5647 (5MP CMOS) - Endereco I2C de 7 bits: 0x36
 * Compativel com: ESP32 / Arduino Due / RP2040 (Logica estrita de 3.3V)
 * ============================================================================
 */

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

// Endereco I2C (SCCB) de 7 bits do sensor OmniVision OV5647
static constexpr uint8_t OV5647_I2C_ADDR = 0x36;

// Mapa de registradores internos de 16 bits do datasheet OV5647
static constexpr uint16_t REG_SYSTEM_RESET     = 0x0103; // Bit[0]=1 aplica Software Reset
static constexpr uint16_t REG_MODE_SELECT      = 0x0100; // 0x00 = Standby, 0x01 = Streaming
static constexpr uint16_t REG_CHIP_ID_HIGH     = 0x300A; // Valor esperado: 0x56
static constexpr uint16_t REG_CHIP_ID_LOW      = 0x300B; // Valor esperado: 0x47
static constexpr uint16_t REG_AEC_PK_MANUAL    = 0x3503; // Controle manual de AEC/AGC
static constexpr uint16_t REG_ISP_PRE_CTRL00   = 0x503D; // Bit[7]=1 habilita Color Bar Test Pattern

// Pinos utilizados no ESP32 (ajuste conforme sua placa de 3.3V)
#if defined(ESP32)
static constexpr int PIN_I2C_SDA  = 21; // Conectado ao Pino 14 do FFC (CAM_SDA)
static constexpr int PIN_I2C_SCL  = 22; // Conectado ao Pino 13 do FFC (CAM_SCL)
static constexpr int PIN_CAM_GPIO = 4;  // Conectado ao Pino 11 do FFC (CAM_GPIO / Enable)
#else
static constexpr int PIN_CAM_GPIO = 4;  // Em placas 3.3V padrao, usa SDA/SCL nativos
#endif

/**
 * Escreve 1 byte (8 bits) em um registrador de endereco de 16 bits do OV5647
 */
bool ov5647WriteReg(uint16_t regAddr, uint8_t value) {
  Wire.beginTransmission(OV5647_I2C_ADDR);
  Wire.write(static_cast<uint8_t>((regAddr >> 8) & 0xFF)); // MSB do endereco (Bits 15..8)
  Wire.write(static_cast<uint8_t>(regAddr & 0xFF));        // LSB do endereco (Bits 7..0)
  Wire.write(value);                                       // Dado de 8 bits a gravar
  return (Wire.endTransmission() == 0);
}

/**
 * Le 1 byte (8 bits) a partir de um registrador de endereco de 16 bits do OV5647
 */
bool ov5647ReadReg(uint16_t regAddr, uint8_t &outValue) {
  Wire.beginTransmission(OV5647_I2C_ADDR);
  Wire.write(static_cast<uint8_t>((regAddr >> 8) & 0xFF)); // MSB do endereco
  Wire.write(static_cast<uint8_t>(regAddr & 0xFF));        // LSB do endereco
  if (Wire.endTransmission(false) != 0) {
    return false; // NACK recebido durante o enderecamento
  }

  uint8_t bytesRead = Wire.requestFrom(OV5647_I2C_ADDR, static_cast<uint8_t>(1));
  if (bytesRead == 1 && Wire.available()) {
    outValue = Wire.read();
    return true;
  }
  return false;
}

/**
 * Executa a verificacao completa de hardware e exibe relatorio no Monitor Serial
 */
void diagnosticarCameraOV5647() {
  uint8_t idHigh = 0, idLow = 0;

  Serial.println(F("\n------------------------------------------------------------"));
  Serial.println(F("[TESTE] Iniciando leitura de registradores via SCCB/I2C (0x36)"));

  bool okHigh = ov5647ReadReg(REG_CHIP_ID_HIGH, idHigh);
  bool okLow  = ov5647ReadReg(REG_CHIP_ID_LOW, idLow);

  if (!okHigh || !okLow) {
    Serial.println(F("[ERRO] Sem resposta do endereco 0x36 no barramento I2C!"));
    Serial.println(F("       1. Verifique se o Pino 15 recebe +3.3V estavel."));
    Serial.println(F("       2. Verifique se o Pino 11 (CAM_GPIO) esta em nivel HIGH (3.3V)."));
    Serial.println(F("       3. Confirme os resistores de pull-up (4.7k ohms) em SDA e SCL."));
    return;
  }

  uint16_t chipId = (static_cast<uint16_t>(idHigh) << 8) | idLow;
  Serial.print(F("[OK] Resposta recebida! Chip ID lido: 0x"));
  if (chipId < 0x1000) Serial.print('0');
  Serial.println(chipId, HEX);

  if (chipId == 0x5647) {
    Serial.println(F("[CONFIRMADO] Sensor autentico OmniVision OV5647 (Camera V1.3 5MP)."));

    // Leitura do estado atual de operacao (0x0100) e padrao de teste (0x503D)
    uint8_t modeVal = 0, testPatternVal = 0;
    ov5647ReadReg(REG_MODE_SELECT, modeVal);
    ov5647ReadReg(REG_ISP_PRE_CTRL00, testPatternVal);

    Serial.print(F(" • Registrador MODE_SELECT (0x0100): 0x"));
    Serial.println(modeVal, HEX);
    Serial.print(F(" • Registrador ISP_PRE_CTRL00 (0x503D): 0x"));
    Serial.println(testPatternVal, HEX);
  } else {
    Serial.println(F("[ALERTA] O ID retornado nao corresponde ao padrao 0x5647."));
  }
}

void setup() {
  Serial.begin(115200);
  delay(500);

  Serial.println(F("============================================================"));
  Serial.println(F("RoboBuilders - Diagnostico de Bancada Camera Raspberry Pi V1.3"));
  Serial.println(F("============================================================"));

  // Habilita o regulador LDO interno e o oscilador da placa V1.3 (Pino 11 = HIGH)
  pinMode(PIN_CAM_GPIO, OUTPUT);
  digitalWrite(PIN_CAM_GPIO, HIGH);
  delay(50); // Aguarda estabilizacao das linhas internas AVDD (2.8V) e DVDD (1.5V)

  // Inicializa o barramento I2C em 100 kHz
#if defined(ESP32)
  Wire.begin(PIN_I2C_SDA, PIN_I2C_SCL, 100000UL);
#else
  Wire.begin();
  Wire.setClock(100000UL);
#endif

  diagnosticarCameraOV5647();

  Serial.println(F("\nComandos disponiveis no Monitor Serial:"));
  Serial.println(F("  [d] Executar novo diagnostico de registradores"));
  Serial.println(F("  [c] Ativar gerador de Color Bar Test Pattern (0x503D = 0x80)"));
  Serial.println(F("  [n] Restaurar modo de imagem normal do sensor (0x503D = 0x00)"));
  Serial.println(F("  [r] Aplicar Software Reset no OV5647 (0x0103 = 0x01)"));
}

void loop() {
  if (Serial.available() > 0) {
    char cmd = Serial.read();
    switch (cmd) {
      case 'd':
      case 'D':
        diagnosticarCameraOV5647();
        break;

      case 'c':
      case 'C':
        if (ov5647WriteReg(REG_ISP_PRE_CTRL00, 0x80)) {
          Serial.println(F("[CONFIG] Padrao de barras de cor (Color Bar) ATIVADO no ISP."));
        }
        break;

      case 'n':
      case 'N':
        if (ov5647WriteReg(REG_ISP_PRE_CTRL00, 0x00)) {
          Serial.println(F("[CONFIG] Captura optica normal RESTAURADA (Color Bar desativado)."));
        }
        break;

      case 'r':
      case 'R':
        if (ov5647WriteReg(REG_SYSTEM_RESET, 0x01)) {
          delay(20);
          Serial.println(F("[RESET] Software Reset aplicado com sucesso ao sensor OV5647."));
          diagnosticarCameraOV5647();
        }
        break;

      default:
        break;
    }
  }
}

Projetos

Para expandir a integração deste módulo óptico em sistemas embarcados completos com interface gráfica ou comparar sua aplicação com outras variantes de sensores CSI e plataformas robóticas da RoboBuilders, consulte os guias complementares publicados no blog:

• Câmera Raspberry Pi OV5647 5MP 1080p 3.6mm: Manual Técnico Completo: versão equipada com suporte óptico M12 e anel de foco ajustável manualmente para aplicações de visão industrial e distância macro;
• Câmera Raspberry Pi 5 8MP IMX219 77° FOV Profissional: alternativa de segunda geração baseada no sensor Sony IMX219 de 8 megapixels com cabo nativo de 22 vias para o Raspberry Pi 5;
• Como Instalar os Drivers para o Display 3.5” no Raspberry Pi: guia prático para montar um terminal portátil com tela sensível ao toque exibindo a pré-visualização da câmera diretamente no Raspberry Pi.

Conclusão

Neste manual técnico, foram abordados os fundamentos de hardware, óptica e programação necessários para integrar a Câmera Raspberry Pi V1.3 (OV5647 5MP) com máxima confiabilidade:

• Especificações Ópticas e Arquitetura CMOS: matriz retroiluminada OmniVision OV5647 de $2592 \times 1944$ pixels ($1{,}4\,\mu\text{m}$), lente colimada de foco fixo ($f = 3{,}60\,\text{mm}$, $f/2{,}9$) com distância hiperfocal de $\sim 1{,}60\,\text{m}$ e campo de visão de $54^\circ \times 41^\circ$;
• Parâmetros Elétricos e Pinout FFC: alimentação primária de $+3{,}3\,\text{V}$ DC (consumo típico de $250\,\text{mA}$), pares diferenciais MIPI CSI-2 de $100\,\Omega$ e barramento de controle serial I2C/SCCB no endereço 0x36;
• Instalação Segura e Prevenção de Falhas: orientação correta dos contatos metálicos do cabo flat de 15 vias no conector CSI e proibição estrita de conexão a quente (hot-plugging);
• Comissionamento e Desenvolvimento de Software: ativação na pilha libcamera / rpicam-apps, processamento de visão computacional em tempo real com Picamera2 e OpenCV em Python, e diagnóstico direto de registradores de 16 bits em C++ para plataformas de $3{,}3\,\text{V}$.

Com essas referências de bancada, o módulo está pronto para operar em sistemas de visão computacional, monitoramento contínuo e robótica avançada.

Solução de problemas

Olá! Sou o assistente técnico da RoboBuilders. Descreva seu problema com o Câmera Raspberry Pi V1.3: 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.