Transmitir vídeo con ESP32 Camera Pro Kit

En este tutorial aprenderás a transmitir vídeo desde el ESP32 Camera Pro Kit a través de tu red Wi-Fi local hacia tu navegador web. Básicamente, estamos construyendo una cámara de vigilancia inalámbrica que puedes monitorear desde tu ordenador.

Piezas necesarias

Para este proyecto necesitarás el ESP32 Camera Pro Kit de SunFounder y un cable 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

El SunFounder ESP32 Camera Pro Kit ofrece una plataforma compacta y con muchas funciones para desarrollar aplicaciones de transmisión de vídeo inalámbrica y visión embebida.

En su núcleo está el módulo ESP32 WROOM-32E, un microcontrolador de doble núcleo que integra conectividad Wi-Fi y Bluetooth, junto con una cámara OV2640 capaz de capturar imágenes con resolución de hasta 1600 × 1200.

La placa de extensión incluida en el kit consolida periféricos esenciales como una ranura para tarjeta micro-SD, circuito de carga de batería, pines de expansión GPIO y una interfaz de cámara de 24 pines, ofreciendo flexibilidad y fiabilidad para prototipos y despliegues.

El kit soporta una única batería de litio-ion 18650, permitiendo operación autónoma sin alimentación externa. Su combinación de almacenamiento a bordo, red inalámbrica y funcionalidad de cámara lo hace ideal para escenarios IoT como monitoreo remoto, transmisión en tiempo real y registro de datos.

ESP32 Camera Pro Kit with Battery and Camera — ESP32 Camera Pro Kit con batería y cámara

Especificaciones técnicas

Componente / Característica	Especificación
Microcontrolador	ESP32 WROOM-32E, doble núcleo Xtensa® 32-bit LX6 @ hasta 240 MHz
Conectividad inalámbrica	Wi-Fi 802.11 b/g/n, Bluetooth 4.2 (BR/EDR + BLE)
Módulo de cámara	OV2640, sensor de 2 MP, hasta 1600 × 1200 de resolución, ~68° de campo de visión
Almacenamiento a bordo	Ranura para tarjeta micro-SD (soporta hasta 32 GB, FAT32)
Fuente de alimentación	Batería Li-ion 18650 de 3.7 V (recargable por USB, gestión de carga integrada)
Interfaces de expansión	Pines GPIO hembra, bloque de terminales de tornillo de 14 pines (paso 3.5 mm)
Interfaz de cámara	Conector FFC/FPC de 24 pines (dedicado para OV2640)
Indicadores	LEDs de estado de alimentación (PWR) y carga (CHG)
Interfaces de programación	Micro-USB (UART, alimentación, carga)

Pinout del ESP32 WROOM-32E

Instalación del Core ESP32

Si es tu primer proyecto con una placa de la serie ESP32, primero deberás instalar el core ESP32. Si ya tienes instaladas las placas ESP32 en tu Arduino IDE, puedes saltarte esta sección.

Comienza abriendo el diálogo de Preferencias seleccionando “Preferences…” en el menú “File”. Esto abrirá el diálogo de Preferencias que se muestra a continuación.

En la pestaña Settings encontrarás un cuadro de edición en la parte inferior del diálogo etiquetado como “Additional boards manager URLs“:

En este campo copia la siguiente URL:

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

Esto permitirá que el Arduino IDE sepa dónde encontrar las librerías core del ESP32. A continuación instalaremos las placas ESP32 usando el Gestor de Placas.

Abre el Gestor de Placas vía «Tools -> Boards -> Board Manager». Verás el Gestor de Placas en la barra lateral izquierda. Escribe «ESP32» en el campo de búsqueda superior y deberías ver dos tipos de placas ESP32; las «Arduino ESP32 Boards» y las placas «esp32 de Espressif». Queremos las librerías esp32 de Espressif. Haz clic en el botón INSTALL y espera hasta que la descarga e instalación finalicen.

Install ESP32 Core libraries — Instalar librerías Core ESP32

Selección de placa

Finalmente necesitamos seleccionar una placa ESP32. En el caso del ESP32 Camera Pro Kit, elegimos la genérica «AI Thinker ESP32-CAM». Para ello, haz clic en el menú desplegable y luego en «Select other board and port…»:

Drop-down Menu for Board Selection — Menú desplegable para selección de placa

Esto abrirá un diálogo donde puedes escribir «ai» en la barra de búsqueda. Verás la placa «AI Thinker ESP32-CAM» bajo Boards. Haz clic en ella y en el puerto COM para activarla y luego pulsa OK:

Board Selection Dialog "AI Thinker ESP32-CAM" board — Diálogo de selección de placa «AI Thinker ESP32-CAM»

Alternativamente, también podrías seleccionar la más reciente «ESP32 Dev Module«, pero en este caso debes habilitar PSRAM y Huge APP en el menú Tools.

Ten en cuenta que debes conectar la placa mediante el cable USB a tu ordenador antes de poder seleccionar un puerto COM.

Transmisión de vídeo

En este proyecto implementamos un servidor de transmisión de vídeo que corre en el ESP32, el microprocesador integrado en el ESP32 Camera Pro Kit. La cámara captura imágenes y el ESP32 las sirve vía Wi-Fi. Tu router Wi-Fi transporta estas imágenes a un navegador web, que las muestra como una transmisión de vídeo. La imagen a continuación ilustra la configuración:

Ten en cuenta que la transmisión de vídeo no está cifrada ni es segura, pero solo será visible en una URL dentro de tu red Wi-Fi local, por ejemplo 192.168.2.39/stream. Solo alguien con acceso a tu red Wi-Fi podrá ver la transmisión.

Código para servidor de vídeo

El siguiente código Arduino implementa el servidor de transmisión de vídeo que envía un flujo MJPEG continuo desde el ESP32 Camera Pro Kit a cualquier navegador conectado a la misma red Wi-Fi.

Usaremos la esp32cam librería, que facilita el manejo de la cámara. Puedes instalarla vía el Library Manager en el Arduino IDE. Solo busca «esp32cam» y pulsa INSTALL. La imagen a continuación muestra la instalación completada:

esp32cam library installed via Library Manager — Librería esp32cam instalada vía Library Manager

A continuación está el código completo para el servidor de transmisión de vídeo. Échale un vistazo rápido y luego entraremos en detalles:

#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

El código comienza incluyendo las librerías necesarias:

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

Estas librerías habilitan la funcionalidad de servidor HTTP (WebServer.h), conectividad Wi-Fi (WiFi.h) y control de cámara (esp32cam.h).

Constantes

A continuación definimos algunas constantes:

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

Las variables WIFI_SSID y WIFI_PASS almacenan las credenciales de la red Wi-Fi. Deberás reemplazar SSID y PASSWORD con los datos reales de tu red Wi-Fi.

La URL es la ruta en la que se servirá la transmisión de vídeo. Puedes cambiarla por lo que quieras. Por ejemplo, «/video» o «/frontdoo«, solo asegúrate de mantener la barra (‘/’) al inicio.

La RESOLUTION establece la resolución deseada para la cámara usando la librería esp32cam.

Aquí tienes una lista de los posibles valores para la resolución de la cámara, aunque dependiendo de la cámara usada no todos pueden 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

Puedes imprimir la lista de resoluciones de cámara usando la siguiente función:

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

Ten en cuenta que la resolución afectará la tasa máxima de frames por segundo. Con una resolución de 1600×1200 no obtendrás mucho más de 10 fps.

Objetos

La siguiente línea crea un objeto servidor HTTP que escucha en el puerto 80. Ese es nuestro servidor web que provee la transmisión de vídeo.

WebServer server(80);

handleStream

La función handleStream() maneja la transmisión de vídeo cada vez que un cliente accede a la ruta /stream:

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

Esta línea obtiene el cliente actual conectado al servidor. Luego se prepara la respuesta:

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

Este encabezado indica al navegador que recibirá un flujo MJPEG multipartes, donde cada parte está separada por un límite llamado frame.

Dentro de un bucle, la función captura un frame de la cámara:

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

Si se captura un frame con éxito, se construye un encabezado describiendo la imagen JPEG, y luego se envía al 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

La función initCamera() configura y arranca el hardware de la 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);
}

Aquí se crea un objeto Config. La función setPins configura los pines de la cámara según el diseño de la placa AiThinker, que también funciona para el ESP32 Camera Pro Kit. setResolution define la resolución a usar, mientras que setBufferCount determina cuántos buffers de imagen se usan internamente.

La función setJpeg establece la calidad de compresión JPEG. 80 es un buen equilibrio entre calidad y tamaño. 90 ofrece mejor calidad pero menor reducción de tamaño. Para vídeo más rápido puedes reducir la resolución y la compresión JPEG, aunque obviamente obtendrás imágenes más pequeñas y de menor calidad.

Finalmente, Camera.begin(cfg) inicializa la cámara con estas configuraciones.

initWifi

La función initWifi() conecta el ESP32 a la red 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) desactiva la escritura de credenciales en flash, lo que acelera la reconexión. El dispositivo se pone en modo station mode (WIFI_STA), y trata de conectarse al Wi-Fi con las credenciales dadas.

Una vez conectado, la dirección IP y la ruta de transmisión se imprimen en el monitor serial. Deberás copiar y pegar esta URL impresa en la barra de direcciones de tu navegador para ver la transmisión. La URL real dependerá de tu ESP32. En mi caso veo la siguiente URL en el Monitor Serial:

Streaming URL printed to Serial Monitor — URL de transmisión impresa en Monitor Serial

Por lo tanto, copio «http://192.168.2.39/stream» en la barra de direcciones de mi navegador Chrome para acceder al vídeo.

initServer

La función initServer() vincula la ruta de transmisión al manejador y arranca el servidor:

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

Esto mapea cualquier petición a /stream a la función handleStream(), y luego inicia el servidor.

setup

La función setup() se ejecuta una vez al arrancar:

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

Inicia la comunicación serial, conecta al Wi-Fi, inicializa la cámara y configura el servidor web.

loop

Finalmente, la función loop() maneja continuamente las peticiones HTTP entrantes:

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

Esta línea permite que el ESP32 responda a las peticiones de los clientes invocando cualquier manejador registrado como handleStream().

Para cargar ese código en tu módulo ESP32, asegúrate de seleccionar la placa AI Thinker ESP32-CAM:

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

Conclusiones

En este tutorial aprendiste a transmitir vídeo con el ESP32 Camera Pro Kit a través de tu red Wi-Fi local hacia tu navegador web.

Con la batería incluida, soporte de carga y los terminales de tornillo en la placa de extensión, es muy fácil construir un sistema de vigilancia alimentado por batería sin necesidad de soldar. Por ejemplo, podrías conectar una luz y una bocina para sonar una alarma cuando se detecte movimiento. Echa un vistazo a nuestro Motion Activated ESP32-CAM tutorial para más información.

Ten en cuenta que la placa de extensión del ESP32 Camera Pro Kit es relativamente grande. Si necesitas una placa más pequeña con cámara, podrías usar la XIAO-ESP32-S3-Sense. Es muy pequeña, pero si quieres conectar hardware adicional necesitas saber soldar.

Una vez que tengas una transmisión de vídeo, también podrías empezar a detectar objetos en el vídeo. Consulta nuestro Object Detection with ESP32-CAM and YOLO tutorial. Está escrito para el ESP32-CAM pero solo requiere un cambio mínimo (cfg.setPins(pins::AiThinker)) para funcionar con el ESP32 Camera Pro Kit.

Finalmente, echa un vistazo a SunFounders Wiki for the ESP32 Camera Pro Kit. Allí encontrarás información y proyectos adicionales.

Si tienes alguna pregunta, no dudes en dejarla en la sección de comentarios.

¡Feliz bricolaje! 😉

Stefan Maetschke