OCR de placa para estacionamento: como automatizar entrada e saída sem cancela

Quem opera estacionamento sabe: o ticket impresso é responsável por uma fração desproporcional dos seus problemas operacionais. Cliente perde, dispensador trava, papel acaba às 23h de domingo, fila de carro buzinando. E o leitor de tag (RFID) resolve uma parte, mas exige que cada cliente recorrente tenha tag — você ainda precisa de fallback para visitantes.

A solução que está virando padrão em shoppings novos, hospitais e edifícios corporativos é eliminar tudo isso e identificar o veículo só pela placa. Câmera lê na entrada, sistema cobra na saída, cancela abre. Sem ticket, sem tag, sem fila.

Este post é um guia técnico-operacional de como montar isso. Vou cobrir hardware (que câmera comprar), arquitetura de software (o que cada componente faz), integração com ERP existente, e ROI realista comparado ao sistema tradicional.

A arquitetura num diagrama

[Câmera IP na cancela]
        │
        ▼
[Sensor de presença / loop indutivo]  ← detecta carro
        │
        ▼
[Servidor local ou edge]
        │
        ▼
[API de OCR de placa]  → retorna { plate, confidence }
        │
        ▼
[Backend do estacionamento]
        ├─ Cliente recorrente? → cobra mensalidade, abre cancela
        ├─ Já está dentro? → calcula tempo, cobra na saída, abre
        └─ Cliente novo? → cadastra, abre, registra entrada
        │
        ▼
[Cancela / catraca]

Cada componente tem decisão de produto importante. Vou um por um.

Hardware: que câmera comprar

A precisão do OCR depende muito mais do input do que do modelo. Se a câmera é ruim, qualquer API erra. Se a câmera é boa, qualquer API acerta.

Especificação mínima viável

O ponto crítico é o shutter speed. Carro a 30 km/h percorre ~8 metros por segundo. Câmera com shutter de 1/30 produz borrão de movimento que o OCR não lê. Por isso shutter de 1/1000 ou mais rápido — congela o frame.

Modelos populares no Brasil

Não vou recomendar marca específica (cada um tem sua opinião), mas faixas de preço típicas:

• Câmera entry-level com LPR profile: Intelbras VIP-3240 LPR / Hikvision DS-2CD2T46G2 — R$ 1.500 – 2.500
• Mid-range LPR dedicada: Hikvision DS-TCG225 / Dahua ITC237 — R$ 3.500 – 6.000
• Premium (zonas de alta velocidade): Bosch DINION IP starlight 8000 / Axis Q1798 — R$ 12.000+

Para estacionamento de velocidade baixa (<20 km/h), entry-level com LPR profile já entrega.

Posicionamento da câmera

Tão importante quanto o modelo:

• Altura: 1.0 a 1.5 m do chão (altura média da placa do carro)
• Distância do ponto de leitura: 4 a 8 metros (longe demais = letras pequenas; perto demais = ângulo ruim)
• Ângulo horizontal: 0° a 30° em relação à direção do carro (frontal, levemente desviado para evitar reflexo direto de farol)
• Ângulo vertical: plano com o chão, não inclinado para baixo
• Iluminação: IR ativo de noite + iluminação ambiente boa de dia (sombra de marquise atrapalha)

Sensor de presença: opcional mas útil

Você não precisa do OCR rodando 24 frames por segundo, 24 horas por dia. Custa muito (chamadas à API) e gera ruído (carros passando na rua, pessoas caminhando).

Solução clássica: loop indutivo no asfalto (a fita de cobre que detecta massa metálica) ou sensor infravermelho na cancela. Quando o sensor dispara, aí você captura o frame e manda pra OCR.

Custo: R$ 200 – 600 instalado.

Alternativa mais moderna: detecção de movimento via vídeo no próprio NVR — câmera detecta o carro chegando e dispara. Funciona, mas tem mais falsos positivos.

Software: a integração

Esquema de software de um estacionamento moderno:

Camada 1 — Captura

Componente que conversa com a câmera. Pode ser:

• VMS dedicado (Milestone, Genetec, Bosch) — robusto, caro, exige integração
• Servidor próprio em Node/Python que consome RTSP da câmera — barato, mais trabalho

Para projeto pequeno-médio, recomendo o segundo. Exemplo em Node.js:

import { spawn } from 'node:child_process'

// FFmpeg consumindo RTSP da câmera, salvando 1 frame quando solicitado
function captureFrame(cameraId) {
  return new Promise((resolve, reject) => {
    const url = cameraConfig[cameraId].rtsp
    const path = `/tmp/${cameraId}-${Date.now()}.jpg`
    const ff = spawn('ffmpeg', [
      '-y', '-i', url,
      '-frames:v', '1', '-q:v', '2',
      path,
    ])
    ff.on('close', code => code === 0 ? resolve(path) : reject(new Error('capture failed')))
  })
}

Camada 2 — OCR

Aqui você usa uma API gerenciada (recomendado) ou roda modelo próprio.

import { readFile } from 'node:fs/promises'

async function readPlate(framePath) {
  const buffer = await readFile(framePath)
  const res = await fetch('https://leituradeplaca.com.br/api/v1/read-plate', {
    method: 'POST',
    headers: {
      'X-API-Key': process.env.LEITURADEPLACA_KEY,
      'Content-Type': 'image/jpeg',
    },
    body: buffer,
  })
  return res.json()
  // { plate: "ABC1D34", confidence: 0.94, error: null, latency_ms: 2410 }
}

Camada 3 — Lógica de negócio

async function handleEntry(cameraId) {
  const frame = await captureFrame(cameraId)
  const { plate, confidence } = await readPlate(frame)

  if (!plate || confidence < 0.7) {
    // Fallback: chama atendente ou abre fluxo manual
    return alertOperator(cameraId, 'unreadable')
  }

  const customer = await db.customers.findByPlate(plate)

  if (customer?.subscription === 'monthly') {
    // Mensalista: abre direto
    await openGate(cameraId)
    await db.events.insert({ plate, type: 'entry', cameraId, ts: new Date() })
    return
  }

  if (customer?.activeSession) {
    // Já está dentro? Não devia entrar de novo. Erro provavelmente
    return alertOperator(cameraId, 'already_inside')
  }

  // Visitante novo: registra entrada, abre cancela
  await db.sessions.insert({ plate, entry: new Date(), cameraId })
  await openGate(cameraId)
}

async function handleExit(cameraId) {
  const frame = await captureFrame(cameraId)
  const { plate, confidence } = await readPlate(frame)

  if (!plate || confidence < 0.7) return alertOperator(cameraId, 'unreadable')

  const session = await db.sessions.findActive(plate)
  if (!session) return alertOperator(cameraId, 'no_entry_record')

  const minutes = (Date.now() - session.entry.getTime()) / 60000
  const fee = computeFee(minutes, customer?.tier)

  // Cobra: PIX, cartão, ou desconta de saldo do mensalista
  await chargeCustomer(session.customerId, fee)
  await db.sessions.close(session.id, { exit: new Date(), fee })
  await openGate(cameraId)
}

Camada 4 — Interface administrativa

O que o gerente do estacionamento vê:

• Tela com câmeras ao vivo + última placa lida em cada
• Lista de carros atualmente dentro (placa, hora de entrada, tempo decorrido, valor estimado)
• Histórico de eventos com filtros
• Cadastro de mensalistas
• Tabela de tarifa
• Relatórios (faturamento diário, ocupação média, picos)

Pode ser construído em Vue/React, ou comprar pronto. Vários ERPs de estacionamento BR têm módulo LPR — converse com fornecedor.

ROI comparado ao sistema tradicional

Vamos colocar números.

Cenário: estacionamento de 200 vagas, ~8.000 movimentações/mês

Sistema com ticket impresso

Sistema com tag RFID

Sistema com OCR de placa

Comparativo direto

Payback do OCR vs Ticket: ~2 meses. Vs Tag: já paga menos no mês 1.

Tratamento de erros: a parte que ninguém te conta

A vida real tem cantos sujos. Lista do que vai acontecer:

"API não respondeu em 5 segundos"

Implementa timeout + retry (1 vez) + fallback para fluxo manual com atendente.

"API retornou placa mas com confidence baixa (60%)"

Política do sistema: se < 0.7 → 2ª foto + comparação. Se ainda inconsistente → fluxo manual.

"Carro com placa parcialmente coberta por barro/lama"

OCR retorna plate: null. Estação de fallback (atendente recebe alerta, digita manualmente).

"Mesma placa entra duas vezes seguidas (ex: trocou de motorista no estacionamento)"

Política: tolerar 1 segundo entrada-segunda-entrada. Mais que isso, alerta.

"Placa duplicada no banco (clone, fraude)"

Detecção heurística + log + investigar. Aqui não há solução fácil.

"Placa estrangeira (carro de Paraguai/Argentina passando)"

Sua API precisa rejeitar gracefully → fluxo manual para visitantes não-BR.

Próximos passos práticos

Se você está montando estacionamento novo do zero:

1. Especifica câmera LPR adequada (gasta R$ 2.500-5.000 nas 2 câmeras, vale a pena)
2. Compra sensor de presença para disparar captura (não fica chamando API à toa)
3. Configura o servidor local com FFmpeg para captura de frame
4. Integra com API leituradeplaca — Plano Max R$ 49/mês cobre 8k leituras (média de 200 vagas com 40 movimentações/dia)
5. Constrói o backend de cobrança e cadastro (ou compra ERP pronto)
6. Plano de fallback: 1 atendente disponível para casos de não-leitura

Se você está migrando estacionamento existente (tem ticket ou tag instalada):

• Roda OCR em paralelo ao sistema antigo por 30 dias para validar precisão
• Após confiança, desativa o sistema antigo
• Mantém infraestrutura antiga como fallback nos primeiros 6 meses

Recursos relacionados

• Documentação da API de OCR
• LGPD e captação de placa: o que você precisa saber
• Comparativo entre APIs de OCR de placa no Brasil
• Casos de uso por setor
• Tabela de preços

Está montando um projeto de estacionamento e quer cotação para volume customizado (mais de 30k movimentações/mês)? Manda mensagem.