¿Te gustaría abrir el navegador, escribir una dirección y ver al instante lo que está captando una cámara conectada a un microcontrolador de menos de cinco centímetros? Eso es justo lo que resuelve la ESP32 CAM: una placa diminuta con WiFi, ranura microSD y una cámara OV2640 que, con el programa correcto, se convierte en un pequeño servidor web. En esta guía vas a montar ese servidor desde cero, vas a entender cómo entrar a la imagen por mDNS (un nombre tipo camara.local) o directamente por la IP que te asigne el router, y vas a quedar con un código base que después puedes estirar hacia vigilancia, time lapse o visión por computador.
Al terminar vas a tener tres cosas claras: cómo se configura la cámara de la ESP32 CAM en el IDE de Arduino, cómo se levanta un servidor HTTP que entrega un JPG bajo demanda, y cómo depurar los errores típicos de inicialización que aparecen la primera vez. Lo armamos por bloques (hardware, configuración, código y pruebas) para que puedas saltar directo a lo que necesites.
Qué es la ESP32 CAM y por qué es distinta
La ESP32 CAM no es un Arduino con una cámara pegada: es un módulo basado en el SoC ESP32 (doble núcleo, WiFi y Bluetooth) que trae integrados el conector para la cámara OV2640 y una ranura microSD. La gracia es que todo el procesamiento de la imagen y la pila de red corren en la misma placa, así que no necesitas un computador haciendo de intermediario.
Hay un detalle que sorprende a quien la usa por primera vez: la placa no tiene puerto USB. Para cargarle el programa necesitas un conversor USB a TTL (o la placa programadora ESP32 CAM MB que a veces viene en el kit). Esto no es un capricho: el espacio de la placa se reservó para la PSRAM y el conector de la cámara, que es lo que de verdad importa para trabajar con imágenes.
La OV2640 es un sensor de 2 megapíxeles capaz de varias resoluciones. En la práctica, con la ESP32 CAM conviene quedarse en resoluciones medias: a mayor resolución, más RAM y más tiempo de captura, y por encima de cierto punto la calidad ni siquiera mejora de forma notoria para un servidor web casero.
Lo que necesitas
- Placa ESP32 CAM con el módulo ESP32 S (el cerebro WiFi del proyecto).
- Cámara OV2640 con su flex (suele venir incluida con la placa; va conectada al zócalo plano).
- Conversor USB a TTL o placa programadora ESP32 CAM MB, solo para cargar el código.
- Cables jumper hembra a hembra si programas con conversor externo.
- Una red WiFi 2.4 GHz (la ESP32 no se conecta a redes de 5 GHz).
Preparar el IDE de Arduino
Antes de compilar necesitas dos cosas en el IDE de Arduino. Primero, el soporte de placas ESP32: ve a Archivo, Preferencias y agrega esta URL en Gestor de URLs adicionales de tarjetas, después instálala desde el Gestor de tarjetas buscando "esp32".
https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
Segundo, la librería de la cámara. El código usa esp32cam (el wrapper de yoursunny), así que instálala desde el Gestor de librerías o desde su repositorio. Una vez instalada, selecciona la tarjeta AI Thinker ESP32 CAM en el menú de placas.
Cómo funciona el programa
El programa se apoya en cuatro funciones, y entenderlas hace que el código largo deje de dar miedo:
conectaWiFi(): levanta la conexión a tu red usando las variablesssidypassword, y además registra el nombre mDNS para poder entrar porcamara.localen lugar de memorizar la IP.servirImagen(): captura un cuadro con la OV2640 y lo entrega al navegador como un JPG. Si la captura falla, responde con un error 503 en vez de colgarse.error404(): la respuesta para cualquier URL que el servidor no reconozca.setup()yloop(): elsetup()configura la cámara (pines, resolución, calidad JPEG) y arranca el servidor; elloop()solo atiende las conexiones entrantes.
Sobre la configuración de la cámara, vale la pena detenerse en el bloque del setup(). La línea configuracion.setPins(pins::AiThinker) carga el mapa de pines del modelo AI Thinker, que es el más común. configuracion.setResolution(QVGA) fija la resolución en 320x240, un buen punto de partida. configuracion.setBufferCount(5) reserva cinco cuadros en el buffer y configuracion.setJpeg(80) define la calidad de compresión. Si más adelante quieres más nitidez, puedes subir a VGA (640x480) o SVGA (800x600), pero ten presente que cada salto consume más memoria.
Antes de cargar, recuerda editar dos líneas con los datos de tu red:
const char *ssid = "****";
const char *password = "****";
Código completo
Este es el programa tal cual, listo para copiar al IDE de Arduino. Lo único que debes cambiar son el ssid y el password por los de tu red:
#include <WebServer.h>
#include <WiFi.h>
#include <ESPmDNS.h>
#include "esp_system.h"
#include <esp32cam.h>
static auto HQVGA = esp32cam::Resolution::find(240, 160);
static auto QVGA = esp32cam::Resolution::find(320, 240);
static auto WQVGA = esp32cam::Resolution::find(400, 240);
static auto VGA = esp32cam::Resolution::find(640, 480);
static auto SVGA = esp32cam::Resolution::find(800, 600);
const char *ssid = "****";
const char *password = "****";
const char *dns = "camara";
WebServer servidor(80);
void conectaWiFi(){
Serial.println();
Serial.print("Connectando a la red: ");
Serial.println(ssid);
WiFi.persistent(false); //Permite que la configuracion del Wifi no sea afectada.
WiFi.mode(WIFI_STA); //Configura el Wifi en modo estacion
WiFi.begin(ssid,password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("WiFi conectado");
Serial.println("Direccion IP: ");
Serial.println(WiFi.localIP());
Serial.println("Direccion MAC: ");
Serial.println(WiFi.macAddress());
//http://camara.local //Servidor dns que sustituye a la IP (solo funciona con Linux o IOS) Para windows se requiere software adicional
if (!MDNS.begin(dns)) {
Serial.print("Se configuro el DNS: http://");
Serial.print(dns);
Serial.println(".local/");
}
else{
MDNS.addService("http", "tcp", 80);
}
}
void error404() {
servidor.send(200, "text/plain", "Error pagina no encontrada");
}
void servirImagen() {
auto frame = esp32cam::capture();
if (frame == nullptr) {
servidor.send(503, "", "");
return;
}
Serial.printf("IMAGEN TOMADA %dx%d %db\n", frame->getWidth(), frame->getHeight(),
static_cast<int>(frame->size()));
servidor.setContentLength(frame->size());
servidor.send(200, "image/jpeg");
WiFiClient client = servidor.client();
frame->writeTo(client);
}
void setup() {
Serial.begin(115200);
using namespace esp32cam;
Config configuracion;
configuracion.setPins(pins::AiThinker);
configuracion.setResolution(QVGA);
configuracion.setBufferCount(5); //Establece el numero de imagenes en el buffer
configuracion.setJpeg(80);
bool ok = Camera.begin(configuracion); //Inicializa la camara con la configuracion previa
Serial.println(ok ? "CAMERA OK" : "Error al inicializar la camara");
conectaWiFi();
servidor.on("/imagen.jpg", servirImagen); //En la funcion servirImagenes se creara la pagina /imagen.jpg
servidor.onNotFound(error404);
servidor.begin();
Serial.println("Servidor iniciado");
}
void loop() {
servidor.handleClient();
}
Cargar y probar
Con el código cargado, abre el Monitor Serial a 115200 baudios y reinicia la placa. Vas a ver el proceso de arranque: el estado de la cámara, la conexión a la red y, lo más importante, la dirección IP que te asignó el router.
Ahora hay dos formas de ver la imagen, según tu sistema operativo:
- Por mDNS (recomendado en Linux y macOS): entra a
http://camara.local/imagen.jpg. El nombrecamaraes el que define la variablednsen el código, así que puedes cambiarlo a tu gusto. En Windows el mDNS no funciona de fábrica y necesitarías software extra, así que conviene usar la otra opción. - Por IP: toma la dirección que mostró el Monitor Serial (en el ejemplo de arriba fue
192.168.100.169, en tu caso será otra) y entra ahttp://LA-IP-QUE-TE-DIO/imagen.jpg. Cada vez que recargues, la ESP32 CAM toma una foto nueva y te la entrega.
Un detalle práctico: si el navegador te redirige solo a https, quítale la s a mano. La ESP32 sirve por HTTP plano, y algunos navegadores fuerzan HTTPS y rompen el acceso a la imagen.
Errores comunes y cómo resolverlos
Esta es la parte que más cuesta la primera vez. Los problemas casi siempre caen en una de estas categorías:
Camera probe failed (0x105)oError al inicializar la camara: casi siempre es el flex de la cámara mal asentado. Apaga la placa, vuelve a insertar el conector plano de la OV2640 firme y derecho, y reintenta. También revisa que seleccionaste la placa AI Thinker correcta.cam_dma_config failedoPSRAM ID read error: indica un problema con la PSRAM. Suele deberse a una fuente que no entrega suficiente corriente. Alimenta la placa con una fuente de 5V estable y de buen amperaje, no solo desde el puerto del conversor.- Errores de compilación con
WiFi.hduplicada o con la resolución: si tienes una versión vieja de la librería ESP32, el IDE puede tomar unaWiFi.hque no corresponde. Asegúrate de instalar el soporte de placas ESP32 con la URL de arriba para tener la versión actualizada. - La cámara funcionaba y dejó de abrir: vuelve a revisar que no estés entrando por
https, y confirma la IP en el Monitor Serial, porque el router puede haberle asignado una distinta.
Variantes y mejoras
Una vez que tengas la imagen funcionando, este código base se presta para crecer:
- Streaming en vivo: en lugar de servir un JPG por petición, puedes armar un stream MJPEG para ver video casi en tiempo real. Es la base de un monitor de mascotas o una mirilla casera.
- Guardar en microSD: la ESP32 CAM trae ranura microSD. Aprovéchala para grabar fotos con marca de tiempo y armar un time lapse, en vez de solo mostrarlas.
- Detección de movimiento: combinando la captura con un sensor PIR puedes disparar la foto solo cuando algo se mueve, y enviar un aviso por Telegram o correo.
- Visión por computador: la OV2640 da resolución suficiente para experimentos sencillos de reconocimiento. Con resoluciones medias puedes alimentar modelos livianos de clasificación de imágenes corriendo en otro equipo.
Personalización para Chile
Para replicar este proyecto con componentes que llegan a tu casa en Chile, esto es lo que conviene tener a mano en MechatronicStore:
- Módulo ESP32 CAM con cámara OV2640 (SKU N-401): es exactamente la placa de esta guía, con la OV2640 y la ranura microSD incluidas. Es la pieza central del proyecto.
- Conversor USB a TTL FTDI FT232RL: lo necesitas solo para cargar el código a la placa, ya que la ESP32 CAM no trae puerto USB. Cualquier conversor USB a serial cumple esta función; con seleccionar 5V en el conversor y conectar TX, RX, GND y 5V basta para programar.
Si el módulo ESP32 CAM aparece momentáneamente agotado, conviene esperar la reposición antes que reemplazarlo por otra placa: la OV2640 y el mapa de pines AI Thinker son específicos, y este código está escrito para esa combinación.
Recursos
- Tutorial original (en español): ESP32 CAM como servidor Web con cámara, por el Dr. Rubén Estrada Marmolejo para HeTPro Tutoriales (Guadalajara, México).
- Librería de la cámara: esp32cam de yoursunny
- Soporte de placas ESP32 para Arduino: Soporte ESP32 para Arduino, de Espressif
Versión chilena reescrita con explicaciones ampliadas y componentes en stock local en MechatronicStore. Esta guía está basada en el trabajo del autor original; el crédito del programa y del enfoque es suyo.
