Transmitir Vídeo com o ESP32 Camera Pro Kit

Neste tutorial, vais aprender a transmitir vídeo do ESP32 Camera Pro Kit pela tua rede Wi-Fi local para o teu navegador Web. Estamos basicamente a construir uma câmara de vigilância sem fios que podes monitorizar a partir do teu computador.

Peças Necessárias

Para este projeto, vais precisar do ESP32 Camera Pro Kit da SunFounder e de um cabo USB.

ESP32 Camera Pro Kit

Find at Amazon

Find at SunFounder

Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.

SunFounder ESP32 Camera Pro Kit

OSunFounder ESP32 Camera Pro Kit oferece uma plataforma compacta e rica em funcionalidades para desenvolver aplicações de streaming de vídeo sem fios e visão embutida.

No seu núcleo está o módulo ESP32 WROOM-32E, um microcontrolador dual-core que integra conectividade Wi-Fi e Bluetooth, emparelhado com uma câmara OV2640 capaz de capturar imagens até 1600 × 1200 de resolução.

A placa de extensão incluída no kit consolida periféricos essenciais como um slot para cartão micro-SD, circuito de carregamento de bateria, cabeçalhos de expansão GPIO e uma interface de câmara de 24 pinos, oferecendo flexibilidade e fiabilidade para prototipagem e implementação.

O kit suporta uma única bateria de iões de lítio 18650, permitindo operação autónoma sem alimentação externa. A sua combinação de armazenamento onboard, rede sem fios e funcionalidade de câmara torna-o ideal para cenários IoT como monitorização remota, streaming em tempo real e registo de dados.

ESP32 Camera Pro Kit with Battery and Camera — ESP32 Camera Pro Kit com Bateria e Câmara

Especificações Técnicas

Componente / Funcionalidade	Especificação
Microcontrolador	ESP32 WROOM-32E, dual-core Xtensa® 32-bit LX6 @ até 240 MHz
Sem fios	Wi-Fi 802.11 b/g/n, Bluetooth 4.2 (BR/EDR + BLE)
Módulo de Câmara	OV2640, sensor de 2 MP, até 1600 × 1200 de resolução, ~68° FOV
Armazenamento onboard	Slot para cartão micro-SD (suporta até 32 GB, FAT32)
Fonte de Alimentação	Bateria Li-ion 18650 de 3,7 V (recarregável via USB, gestão de carga onboard)
Interfaces de Expansão	Cabeçalhos GPIO fêmea, bloco de terminais de parafuso de 14 pinos (passo de 3,5 mm)
Interface da Câmara	Conector FFC/FPC de 24 pinos (dedicado para OV2640)
Indicadores	LEDs de estado de energia (PWR) e carregamento (CHG)
Interfaces de Programação	Micro-USB (UART, energia, carregamento)

Pinout do ESP32 WROOM-32E

Instalação do Core ESP32

Se este for o teu primeiro projeto com uma placa da série ESP32, precisarás de instalar primeiro o core ESP32. Se já tens placas ESP32 instaladas no teu Arduino IDE, podes saltar esta secção.

Começa por abrir o diálogo de Preferências selecionando “Preferences…” no menu “File”. Isto abrirá o diálogo de Preferências mostrado abaixo.

Na aba Settings encontrarás uma caixa de edição na parte inferior do diálogo rotulada “Additional boards manager URLs“:

Neste campo de entrada copia a seguinte URL:

https://espressif.github.io/arduino-esp32/package_esp32_dev_index.json

Isto permite ao Arduino IDE saber onde encontrar as bibliotecas do core ESP32. A seguir, vamos instalar as placas ESP32 usando o Boards Manager.

Abre o Boards Manager via “Tools -> Boards -> Board Manager”. Verás o Boards Manager aparecer na barra lateral esquerda. Introduz “ESP32” no campo de pesquisa no topo e deverás ver dois tipos de placas ESP32; as “Arduino ESP32 Boards” e as “esp32 by Espressif”. Queremos as bibliotecas esp32 da Espressif. Clica no botão INSTALL e espera até o download e instalação estarem completos.

Install ESP32 Core libraries — Instalar bibliotecas Core ESP32

Seleção da Placa

Finalmente, precisamos de selecionar uma placa ESP32. No caso do ESP32 Camera Pro Kit, escolhemos a genérica “AI Thinker ESP32-CAM”. Para isso, clica no menu suspenso e depois em “Select other board and port…”:

Drop-down Menu for Board Selection — Menu suspenso para seleção da placa

Isto abrirá um diálogo onde podes digitar “ai” na barra de pesquisa. Verás a placa “AI Thinker ESP32-CAM” em Boards. Clica nela e no porto COM para ativá-la e depois clica OK:

Board Selection Dialog "AI Thinker ESP32-CAM" board — Diálogo de seleção da placa “AI Thinker ESP32-CAM”

Alternativamente, poderias também selecionar a mais recente “ESP32 Dev Module“, mas neste caso tens de ativar PSRAM e Huge APP no menu Tools.

Nota que precisas de ligar a placa via cabo USB ao teu computador antes de poderes selecionar uma porta COM.

Streaming de Vídeo

Neste projeto estamos a implementar um servidor de streaming de vídeo que corre no ESP32, que é o microprocessador integrado no ESP32 Camera Pro Kit. A câmara captura imagens e o ESP32 serve-as via Wi-Fi. O teu router Wi-Fi transporta estas imagens para um navegador Web, que as exibe como um fluxo de vídeo. A imagem abaixo ilustra a configuração:

Nota que o fluxo de vídeo não é encriptado nem seguro, mas será visível apenas numa URL dentro da tua rede Wi-Fi local, por exemplo 192.168.2.39/stream. Só quem tiver acesso à tua rede Wi-Fi poderá ver o fluxo de vídeo.

Código para Servidor de Vídeo

O seguinte código Arduino implementa o servidor de streaming de vídeo que envia um fluxo MJPEG contínuo do ESP32 Camera Pro Kit para qualquer navegador web ligado à mesma rede Wi-Fi.

Vamos usar a esp32cam biblioteca, que simplifica o controlo da câmara. Podes instalá-la via Library Manager no Arduino IDE. Basta procurar por “esp32cam” e carregar em INSTALL. A imagem abaixo mostra a instalação concluída:

esp32cam library installed via Library Manager — Biblioteca esp32cam instalada via Library Manager

Abaixo está o código completo para o servidor de streaming de vídeo. Dá uma vista rápida e depois explicamos os detalhes:

#include "WebServer.h"
#include "WiFi.h"
#include "esp32cam.h"

const char* WIFI_SSID = "SSID";
const char* WIFI_PASS = "PASSWORD";
const char* URL = "/stream";
const auto RESOLUTION = esp32cam::Resolution::find(1024, 768);

WebServer server(80);

void handleStream() {
  static char head[128];
  WiFiClient client = server.client();

  server.sendContent("HTTP/1.1 200 OK\r\n"
                     "Content-Type: multipart/x-mixed-replace; "
                     "boundary=frame\r\n\r\n");

  while (client.connected()) {
    auto frame = esp32cam::capture();
    if (frame) {
      sprintf(head,
              "--frame\r\n"
              "Content-Type: image/jpeg\r\n"
              "Content-Length: %ul\r\n\r\n",
              frame->size());
      client.write(head, strlen(head));
      frame->writeTo(client);
      client.write("\r\n");
    }
  }
}

void initCamera() {
  using namespace esp32cam;
  Config cfg;
  cfg.setPins(pins::AiThinker);
  cfg.setResolution(RESOLUTION);
  cfg.setBufferCount(2);
  cfg.setJpeg(80);
  Camera.begin(cfg);
}

void initWifi() {
  WiFi.persistent(false);
  WiFi.mode(WIFI_STA);
  WiFi.begin(WIFI_SSID, WIFI_PASS);
  while (WiFi.status() != WL_CONNECTED) {
    delay(100);
  }
  Serial.printf("Stream at: http://%s%s\n",
                WiFi.localIP().toString().c_str(), URL);
}

void initServer() {
  server.on(URL, handleStream);
  server.begin();
}

void setup() {
  Serial.begin(115200);
  initWifi();
  initCamera();
  initServer();
}

void loop() {
  server.handleClient();
}

Includes

O código começa por incluir as bibliotecas necessárias:

#include "WebServer.h"
#include "WiFi.h"
#include "esp32cam.h"

Estas bibliotecas permitem a funcionalidade de servidor HTTP (WebServer.h), conectividade Wi-Fi (WiFi.h) e controlo da câmara (esp32cam.h).

Constantes

De seguida, definimos algumas constantes:

const char* WIFI_SSID = "SSID";
const char* WIFI_PASS = "PASSWORD";
const char* URL = "/stream";
const auto RESOLUTION = esp32cam::Resolution::find(1024, 768);

As variáveis WIFI_SSID e WIFI_PASS guardam as credenciais da rede Wi-Fi. Terás de substituir SSID e PASSWORD pelos dados reais da tua rede Wi-Fi.

O URL é o caminho onde o fluxo de vídeo será servido. Podes alterar para o que quiseres. Por exemplo, “/video” ou “/frontdoor”, só certifica-te de manter a barra (‘/’) no início.

O RESOLUTION define a resolução desejada para a câmara usando a biblioteca esp32cam.

Aqui está uma lista dos valores possíveis para a resolução da câmara, embora dependendo da câmara usada nem todos possam funcionar:

96×96
160×120
128×128
176×144
240×176
240×240
320×240
320×320
400×296
480×320
640×480
800×600
1024×768
1280×720
1280×1024
1600×1200

Podes imprimir a lista de resoluções da câmara usando a seguinte função:

void printResolutions() {
  Serial.println("Camera resolutions:");
  for (auto res : esp32cam::Camera.listResolutions()) {
    Serial.printf("%dx%d\n", res.getWidth(), res.getHeight());
  }
}

Nota que a resolução afeta a taxa máxima de frames. Com 1600×1200 não vais conseguir mais do que cerca de 10 frames por segundo.

Objetos

A linha seguinte cria um objeto servidor HTTP que escuta na porta 80. Esse é o nosso servidor web que fornece o fluxo de vídeo.

WebServer server(80);

handleStream

A função handleStream() trata do fluxo de vídeo sempre que um cliente acede ao caminho /stream:

void handleStream() {
  static char head[128];
  WiFiClient client = server.client();

Esta linha obtém o cliente atual ligado ao servidor. A resposta é então preparada:

server.sendContent("HTTP/1.1 200 OK\r\n"
                   "Content-Type: multipart/x-mixed-replace; "
                   "boundary=frame\r\n\r\n");

Este cabeçalho informa o navegador que vai receber um fluxo MJPEG multipart, onde cada parte é separada por um limite chamado frame.

Dentro de um ciclo, a função captura um frame da câmara:

  while (client.connected()) {
    auto frame = esp32cam::capture();

Se um frame for capturado com sucesso, é construído um cabeçalho que descreve a imagem JPEG, e depois enviado ao cliente como JPEG:

    if (frame) {
      sprintf(head,
              "--frame\r\n"
              "Content-Type: image/jpeg\r\n"
              "Content-Length: %ul\r\n\r\n",
              frame->size());
      client.write(head, strlen(head));
      frame->writeTo(client);
      client.write("\r\n");
    }

initCamera

A função initCamera() configura e inicia o hardware da câmara:

void initCamera() {
  using namespace esp32cam;
  Config cfg;
  cfg.setPins(pins::AiThinker);
  cfg.setResolution(RESOLUTION);
  cfg.setBufferCount(2);
  cfg.setJpeg(80);
  Camera.begin(cfg);
}

Aqui, é criado um objeto Config. A função setPins configura os pinos da câmara com base no layout da placa AiThinker, que também funciona para o ESP32 Camera Pro Kit. setResolution define a resolução a usar, enquanto setBufferCount determina quantos buffers de imagem são usados internamente.

A função setJpeg define a qualidade da compressão JPEG. 80 é um bom equilíbrio entre qualidade e tamanho. 90 dá melhor qualidade mas menor redução do tamanho da imagem. Para vídeo mais rápido podes reduzir a resolução e a compressão JPEG, mas obviamente terás imagens menores e de qualidade inferior.

Finalmente, Camera.begin(cfg) inicializa a câmara com estas definições.

initWifi

A função initWifi() liga o ESP32 à rede Wi-Fi especificada:

void initWifi() {
  WiFi.persistent(false);
  WiFi.mode(WIFI_STA);
  WiFi.begin(WIFI_SSID, WIFI_PASS);
  while (WiFi.status() != WL_CONNECTED) {
    delay(100);
  }
  Serial.printf("Stream at: http://%s%s\n",
                WiFi.localIP().toString().c_str(), URL);
}

WiFi.persistent(false) desativa a escrita das credenciais na flash, o que acelera a reconexão. O dispositivo é configurado em modo estação (WIFI_STA), e tenta ligar-se ao Wi-Fi usando as credenciais fornecidas.

Uma vez ligado, o endereço IP e o caminho do fluxo são impressos no monitor serial. Terás de copiar e colar esta URL impressa na barra de endereços do teu navegador para ver o fluxo de vídeo. A URL real dependerá do teu ESP32. No meu caso vejo a seguinte URL no Monitor Serial:

Streaming URL printed to Serial Monitor — URL de Streaming impressa no Monitor Serial

Portanto, copio “http://192.168.2.39/stream” na barra de endereços do meu navegador Chrome para aceder ao vídeo.

initServer

A função initServer() liga o caminho de streaming ao handler e inicia o servidor:

void initServer() {
  server.on(URL, handleStream);
  server.begin();
}

Isto mapeia qualquer pedido a /stream para a função handleStream(), e depois inicia o servidor.

setup

A função setup() corre uma vez no arranque:

void setup() {
  Serial.begin(115200);
  initWifi();
  initCamera();
  initServer();
}

Inicia a comunicação serial, liga ao Wi-Fi, inicializa a câmara e configura o servidor web.

loop

Finalmente, a função loop() trata continuamente os pedidos HTTP recebidos:

void loop() {
  server.handleClient();
}

Esta linha permite ao ESP32 responder a pedidos dos clientes invocando quaisquer handlers registados como handleStream().

Para gravar esse código no teu módulo ESP32, certifica-te de selecionar a placa AI Thinker ESP32-CAM:

Select AI Thinker ESP32-CAM as board — Seleciona AI Thinker ESP32-CAM como placa

Conclusões

Neste tutorial aprendeste a transmitir vídeo com o ESP32 Camera Pro Kit pela tua rede Wi-Fi local para o teu navegador Web.

Com a bateria incluída, suporte de carregamento e os terminais de parafuso na placa de extensão, é muito fácil construir um sistema de vigilância alimentado por bateria sem soldar. Por exemplo, podes ligar uma luz de flash e uma buzina para soar um alarme quando for detetado movimento. Dá uma vista de olhos no nosso Motion Activated ESP32-CAM tutorial para mais informações.

Nota que a placa de extensão do ESP32 Camera Pro Kit é relativamente grande. Se precisares de uma placa menor com câmara, podes usar o XIAO-ESP32-S3-Sense. É muito pequena, no entanto, se quiseres ligar hardware adicional precisas de saber soldar.

Uma vez que tenhas um fluxo de vídeo, podes também começar a detetar objetos no vídeo. Vê o nosso Object Detection with ESP32-CAM and YOLO tutorial. Está escrito para o ESP32-CAM mas requer apenas uma alteração mínima (cfg.setPins(pins::AiThinker)) para funcionar com o ESP32 Camera Pro Kit.

Finalmente, dá uma vista de olhos em SunFounders Wiki for the ESP32 Camera Pro Kit. Lá encontrarás informações adicionais e projetos.

Se tiveres alguma dúvida, não hesites em deixar nos comentários.

Boas experiências a criar 😉

Stefan Maetschke