Reconhecimento de placa para condomínio: arquitetura completa em 2026

A portaria do condomínio é um dos pontos de fricção que mais geram reclamação no Brasil: morador esperando 2 minutos pra entrar, prestador travado no interfone, motorista de aplicativo sem saber o procedimento. Reconhecimento automático de placa muda esse fluxo: o morador encosta na entrada, a câmera lê a placa, o portão abre. Sem clicker, sem buzina, sem porteiro precisando reconhecer.

Este post é o guia completo de arquitetura pra quem quer implementar isso — seja você um síndico avaliando contratar, um administrador montando RFP pra fornecedor, ou um dev pensando em construir o produto.

TL;DR — o que você precisa

1. Câmera adequada posicionada certo (~R$ 800-2.500 cada, 1-2 unidades por entrada)
2. Computador local ou cloud processando os frames (Raspberry Pi 5, mini PC, ou só requisição de cloud)
3. API de OCR de placa (~R$ 50-150/mês de custo recorrente pro condomínio típico)
4. Integração com o controlador do portão (relé GPIO, módulo Wiegand, ou interface IP)
5. Cadastro de moradores com placas autorizadas (banco simples, web admin, app de síndico)
6. Política de privacidade e LGPD documentada

Custo total de implantação: R$ 4.000 a R$ 12.000 dependendo de câmeras existentes e portão. Operacional: R$ 50-200/mês.

A arquitetura padrão

┌─────────────────────────────────────────────────────────────────┐
│  Carro chega                                                     │
│       │                                                          │
│       ▼                                                          │
│  ┌─────────────┐                                                 │
│  │ Câmera ALPR │ (PoE, IP, 4MP, com IR)                          │
│  └──────┬──────┘                                                 │
│         │ frames RTSP ou snapshot HTTP                           │
│         ▼                                                        │
│  ┌────────────────┐                                              │
│  │ Mini PC local  │ (Raspberry Pi 5 ou NUC, R$ 800-2000)         │
│  │ - Frame picker │                                              │
│  │ - API client   │                                              │
│  │ - Whitelist    │                                              │
│  │ - GPIO/Wiegand │                                              │
│  └──────┬─────────┘                                              │
│         │ POST imagem                                            │
│         ▼                                                        │
│  ┌────────────────┐         ┌──────────────────────┐             │
│  │ API OCR placa  │◄────────┤ Cloud OCR (HTTP)     │             │
│  │  (R$ 6-50/k)   │         └──────────────────────┘             │
│  └──────┬─────────┘                                              │
│         │ {plate, confidence}                                    │
│         ▼                                                        │
│  ┌────────────────┐                                              │
│  │ Whitelist?     │ (SQLite local + sync com cloud)              │
│  └─┬────────────┬─┘                                              │
│    │ Sim        │ Não                                            │
│    ▼            ▼                                                │
│  Abre portão  Aciona campainha do porteiro / app de síndico      │
└─────────────────────────────────────────────────────────────────┘

Componente 1: a câmera

A câmera é onde mais se erra. Os requisitos pra ALPR de portaria são diferentes de uma câmera de segurança normal:

Posicionamento

• Altura: 1,2-1,8m do chão. Mais alta que isso e você captura o teto do carro, não a placa.
• Distância: 3-6m do ponto onde o carro para. Mais perto e você pega só parte da placa em ângulo extremo; mais longe e a resolução fica baixa.
• Ângulo: máximo 30° vertical e 30° lateral. Acima disso a precisão cai.
• Iluminação noturna: indispensável luz IR (já vem em câmeras ALPR-grade) ou um refletor LED branco discreto. A placa precisa ser visível, não o entorno.

Resolução e FPS

• Mínimo 2MP (1920×1080) com a placa ocupando pelo menos 100 pixels de largura no frame
• 15 FPS é suficiente — você não precisa de 60. ALPR processa por evento de movimento, não vídeo contínuo.
• Codec H.264 (compatibilidade) ou H.265 (largura de banda menor)

Modelos comuns no Brasil em 2026

• Hikvision DS-2CD7A26G0/P-LZS ou similar: ~R$ 2.000, é literalmente uma câmera ALPR-grade com algoritmo embutido (que você pode bypassar e processar via cloud).
• Intelbras VIP 5450 LPR: ~R$ 1.500, BR-friendly, suporte fácil.
• Câmera IP genérica 4MP + IR (Tiandy, Imou, etc): ~R$ 800. Funciona pra OCR via cloud, mas exige posicionamento mais cuidadoso porque não tem otimizações de hardware pra placa.

Dica: se o condomínio já tem câmeras IP, verifique se elas atendem aos critérios. Em ~30% dos casos a câmera existente serve.

Componente 2: o computador local (controlador)

O cérebro do sistema. Faz três coisas:

1. Captura o frame quando há movimento (ou em intervalo curto)
2. Decide se precisa chamar a API (sensor de presença ou detecção de movimento na câmera)
3. Se a placa está autorizada, manda sinal pro portão

Hardware sugerido

• Raspberry Pi 5 (8GB): R$ 800-1.000 com case e fonte. Rouba a cena pra condomínio pequeno (1 entrada).
• Mini PC Intel N100: R$ 1.500-2.000. Mais robusto, suporta 2-4 câmeras simultâneas.
• NVR com SDK aberto: alguns NVRs já permitem rodar scripts. Verificar caso a caso.

Software (exemplo em Python)

import cv2
import requests
import sqlite3
import RPi.GPIO as GPIO
from pathlib import Path
import os

# GPIO 17 = pino de relé que abre o portão
GPIO.setmode(GPIO.BCM)
GPIO.setup(17, GPIO.OUT)

API_URL = "https://leituradeplaca.com.br/api/v1/read-plate"
API_KEY = os.environ["LDP_API_KEY"]
RTSP = "rtsp://admin:senha@192.168.1.50:554/cam/realmonitor"

db = sqlite3.connect("/var/lib/portaria/whitelist.db")
db.execute("CREATE TABLE IF NOT EXISTS placas (placa TEXT PRIMARY KEY, dono TEXT)")

def autorizada(placa: str) -> str | None:
    row = db.execute("SELECT dono FROM placas WHERE placa = ?", (placa,)).fetchone()
    return row[0] if row else None

def ler_e_decidir():
    cap = cv2.VideoCapture(RTSP)
    ok, frame = cap.read()
    cap.release()
    if not ok:
        return

    _, jpg = cv2.imencode(".jpg", frame)
    res = requests.post(
        API_URL,
        headers={"Authorization": f"Bearer {API_KEY}"},
        files={"image": ("frame.jpg", jpg.tobytes(), "image/jpeg")},
        timeout=15,
    ).json()

    placa = res.get("plate")
    conf = res.get("confidence", 0)
    if not placa or conf < 0.7:
        return

    dono = autorizada(placa)
    if dono:
        print(f"[{placa}] autorizada — {dono}")
        GPIO.output(17, GPIO.HIGH)
        time.sleep(1)
        GPIO.output(17, GPIO.LOW)
    else:
        print(f"[{placa}] NÃO autorizada — alertando porteiro")
        # webhook pra app de síndico, ou aciona campainha

Este é o esqueleto. Em produção você adiciona: detecção de movimento (pra não chamar API toda hora), retry/timeout robusto, log estruturado, sincronia da whitelist com cloud, e um failsafe (se a API cair, libera por ligação ao porteiro).

Componente 3: integração com o portão

Aqui depende muito do controlador do portão existente:

• Portão com central simples (PPA, Garen, RCG): tem um borne de "pulso de abertura". Você fecha o circuito por 0,5-1 segundo via relé do GPIO. R$ 30 de relé + 30 minutos de instalação elétrica.
• Portão com módulo de TAG (Wiegand): você conecta um leitor virtual via emulador Wiegand. Mais complexo, mas integra com sistema existente sem bypass.
• Sistema de controle de acesso IP (HID, Suprema, Dahua DSS): você dispara abertura via API HTTP do controlador. Mais limpo, mas exige documentação do fabricante.

Recomendação prática: comece com relé GPIO + borne de pulso. Migra pra Wiegand/IP só se a administradora exigir integração com o sistema deles.

Componente 4: cadastro de moradores e admin

Mínimo viável:

• Tabela de placas autorizadas (placa, nome, apartamento, bloco, validade)
• Web admin pro síndico/porteiro adicionar/remover (Laravel, Django, Express + admin pronto)
• App de morador (opcional) pra visualizar entradas próprias e cadastrar visitantes temporários

Pra condomínio de 50-200 unidades, planilha sincronizada já resolve no início. Sistema próprio só compensa acima de 200 ou quando o cliente exige integração com app já usado.

Componente 5: LGPD e privacidade

A placa de carro é dado pessoal sob a LGPD quando associada à pessoa identificável (e em condomínio, sempre é). Você precisa:

1. Base legal: legítimo interesse pra controle de acesso. Documente.
2. Aviso visível na entrada: "este local utiliza reconhecimento de placa por câmera. Saiba mais em link"
3. Política de privacidade no site/app do condomínio explicando: o que é coletado, por quê, retenção, com quem compartilha, como solicitar acesso/exclusão
4. Retenção limitada: logs de entrada por 90-180 dias é razoável. Imagens da placa, idealmente, não retidas (só o texto da placa)
5. Acesso restrito: só síndico/zelador podem ver os logs. Porteiro vê em tempo real, sem histórico.

Cubro isso em mais detalhe no post LGPD e placa de veículo.

Importante: nem leituradeplaca nem outras APIs sérias retêm a imagem após processamento. Verifique isso em qualquer fornecedor que considerar.

Custo total realista

Implantação inicial (1 entrada):

• Câmera ALPR: R$ 1.500
• Mini PC ou Pi: R$ 1.000
• Cabeamento, fonte, instalação elétrica: R$ 500-1.000
• Software (custom ou pronto): R$ 0 (DIY) a R$ 3.000 (terceirizado)
• Total: R$ 3.000 a R$ 6.500

Operacional mensal:

• API de OCR (condomínio típico, 1.500-3.000 leituras/mês): R$ 19-49
• Internet (já tem)
• Manutenção esporádica
• Total: R$ 50-100/mês

ROI vs alternativas

Comparado a:

• Porteiro 24/7: R$ 8.000-12.000/mês de folha + encargos. ALPR não substitui o porteiro (você ainda precisa de alguém pra prestador, encomenda, situações), mas reduz carga: ~70% das entradas viram automáticas, porteiro foca no que importa.
• Sistema de tag RFID: R$ 50-100 por TAG, dor de cabeça pra reposição quando perde, não funciona com visitante.
• App com QR code: requer ação ativa do morador toda vez. Adesão fica em 30-50%.

ALPR ganha porque é passivo: morador não faz nada, só passa.

Pegadinhas que vejo em quase todo projeto

1. Tirar a foto na hora errada: muitos sistemas tentam ler enquanto o carro ainda está se movimentando ou está com lombada na frente. Use sensor de presença pra disparar no momento ideal.
2. Confiar 100% no automático: confidence baixa (<0.7) deve cair pro porteiro, não passar errado. Erro de letra confunde "ABC1234" com "ABC1284" e o vizinho do bloco entra no seu lugar.
3. Esquecer das motos: placa de moto é menor e fica em ângulo diferente. Câmera precisa cobrir os dois cenários ou ter modo separado.
4. Não pensar no fallback offline: se a internet cai, o portão precisa continuar funcionando (cair pro modo manual / clicker).
5. Ignorar carros novos sem placa: carro 0-km vem sem placa por algumas horas. Tem que ter procedimento pro síndico.

Próximos passos

Se você está montando um piloto, recomendo:

1. Validar uma câmera só em uma entrada por 30 dias antes de comprar 5
2. Cadastrar 20-30 placas pra teste e medir taxa de acerto real
3. Ajustar posicionamento com base nas falhas observadas
4. Só depois automatizar a abertura do portão

Crie uma conta em leituradeplaca.com.br/signup com 100 leituras de trial por R$ 4,99 — suficiente pra testar a câmera por uma semana antes de assinar plano.

Quer ajuda específica pro seu caso? Mande detalhes pra contato@leituradeplaca.com.br — atendo síndicos e administradoras com piloto guiado gratuito.