Cómo crear videos en time-lapse con ESP32-CAM

Los vídeos en time-lapse son una forma fascinante de capturar eventos que ocurren lentamente, como el movimiento de las nubes, el crecimiento de plantas o el avance de una construcción. Aunque se puede utilizar un smartphone con una aplicación dedicada para crear time-lapses, esto puede resultar incómodo, especialmente si se desea dejar el dispositivo desatendido durante horas. Pero, ¿qué pasaría si pudieras conseguir los mismos resultados utilizando un dispositivo mucho más asequible? Aquí es donde entra en juego el ESP32-CAM, una potente placa de microcontrolador equipada con cámara y capacidades de Wi-Fi, que tiene un costo aproximado de solo $10.

En esta guía, te llevaré a través de los pasos necesarios para configurar tu ESP32-CAM, capturar imágenes a intervalos regulares, almacenarlas en una tarjeta SD y compilarlas en un vídeo time-lapse. ¡Es más sencillo de lo que podrías imaginar! Vamos a ello.

Materiales necesarios

Para este proyecto, necesitarás los siguientes elementos:

• Módulo ESP32-CAM: Este será el cerebro de tu proyecto, encargado de capturar las imágenes.
• Cable Micro USB: Para alimentar y programar el ESP32-CAM.
• Adaptador FTDI o Adaptador ESP32-CAM-MB (opcional): Si tu ESP32-CAM no cuenta con un convertidor USB a serie integrado, necesitarás esto para subir el código.
• Computadora con Arduino IDE: Este software te permitirá escribir y cargar el código en tu ESP32.
• Tarjeta Micro SD: Para almacenar las imágenes capturadas.

Es importante elegir el tipo adecuado de placa ESP32-CAM para este proyecto. Las opciones recomendadas son el ESP32-CAM con la placa hija ESP32-CAM-MB o el más reciente ESP32-CAM-CH340, ya que ambas incluyen un puerto USB para programación y alimentación. Te aconsejo evitar la placa ESP32-CAM básica, ya que requiere un convertidor USB a serie que podrías no tener a mano.

Conectar el ESP32-CAM a la computadora

El módulo ESP32-CAM básico, aunque potente, carece de una interfaz USB integrada para la programación y la comunicación con tu computadora. Esto significa que necesitarás un poco de ayuda para ponerlo en marcha. Tienes tres opciones principales para conectarlo:

Opción 1: ESP32-CAM básico + Adaptador FTDI

Si tienes un módulo ESP32-CAM básico, puedes utilizar un adaptador USB a serie (como un adaptador FTDI) para conectarlo a tu computadora. Asegúrate de que el adaptador esté configurado para 5V, ya que eso es lo que alimentará al ESP32-CAM.

Recuerda que el pin GPIO 0 debe estar conectado a tierra solo durante la programación. Una vez que hayas terminado de cargar el código, debes desconectar esta conexión. ¡No olvides que deberás hacer esta conexión cada vez que quieras subir un nuevo sketch!

Opción 2: ESP32-CAM básico + Adaptador ESP32-CAM-MB

Utilizar el adaptador FTDI para programar el ESP32-CAM puede ser un poco engorroso. Por ello, muchos proveedores venden el módulo ESP32-CAM junto con una pequeña placa hija llamada ESP32-CAM-MB. Simplemente apilas el ESP32-CAM en la placa hija, conectas un cable micro USB, y presionas el botón de carga para programar tu placa. ¡Así de simple!

Opción 3: ESP32-CAM-CH340

Si posees un módulo ESP32-CAM-CH340, ¡estás de suerte! Esta variante incluye un chip CH340 USB a serie integrado, eliminando la necesidad de hardware adicional. Simplemente conéctalo a tu computadora a través de un cable micro USB y estarás listo para comenzar. Recuerda que también necesitarás conectar el pin GPIO0 a GND durante la programación, al igual que con el adaptador FTDI.

Configuración del Arduino IDE

Independientemente de la opción que elijas, la configuración dentro del Arduino IDE es la misma.

Instalación de la placa ESP32

Para utilizar el ESP32-CAM o cualquier ESP32 con el Arduino IDE, primero debes instalar la placa ESP32 (también conocida como el núcleo Arduino ESP32) a través del Administrador de Placas de Arduino.

Si no lo has hecho aún, sigue este tutorial para instalar la placa ESP32:

Seleccionar la placa y el puerto

Una vez que hayas instalado el núcleo Arduino ESP32, reinicia tu Arduino IDE y haz clic en “Seleccionar otra placa y puerto...” en el menú desplegable superior.

Aparecerá una nueva ventana. Busca el tipo específico de placa ESP32 que estás utilizando (en este caso, es el AI Thinker ESP32-CAM).

Después, selecciona el puerto correspondiente a tu placa ESP32-CAM, que generalmente se etiqueta como “/dev/ttyUSB0” (en Linux o macOS) o “COM6” (en Windows).

¡Eso es todo! El Arduino IDE ahora está configurado para el ESP32-CAM.

Subir el código

Ahora, ¡vamos a crear el time-lapse! A continuación, encontrarás el código que hará que esto sea posible.

Por defecto, este código está configurado para tomar una foto cada 30 minutos. Si deseas cambiar esto, edita el número en la línea que dice #define MINUTES_BETWEEN_PHOTOS 30.

#include "esp_camera.h"
#include "FS.h"                // Tarjeta SD ESP32
#include "SD_MMC.h"            // Tarjeta SD ESP32
#include "soc/soc.h"           // Desactivar problemas de brownout
#include "soc/rtc_cntl_reg.h"  // Desactivar problemas de brownout
#include "driver/rtc_io.h"

#define MINUTES_BETWEEN_PHOTOS 30

// Definición de pines para CAMERA_MODEL_AI_THINKER
#define PWDN_GPIO_NUM 32
#define RESET_GPIO_NUM -1
#define XCLK_GPIO_NUM 0
#define SIOD_GPIO_NUM 26
#define SIOC_GPIO_NUM 27

#define Y9_GPIO_NUM 35
#define Y8_GPIO_NUM 34
#define Y7_GPIO_NUM 39
#define Y6_GPIO_NUM 36
#define Y5_GPIO_NUM 21
#define Y4_GPIO_NUM 19
#define Y3_GPIO_NUM 18
#define Y2_GPIO_NUM 5
#define VSYNC_GPIO_NUM 25
#define HREF_GPIO_NUM 23
#define PCLK_GPIO_NUM 22

// Pin del LED Flash
#define FLASH_LED_PIN 4

void setup() {
  WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0);  // Desactivar detector de brownout

  // Inicializar serial
  Serial.begin(115200);
  while (!Serial) delay(100);

  // Inicializar tarjeta SD ANTES de la cámara para reducir presión de memoria
  startMicroSD();

  // Inicializar cámara
  startCamera();

  delay(2000);  // Retraso de 2 segundos antes de la primera foto
}

void loop() {
  // Contar el número de fotos que hemos tomado
  static int number = 0;
  number++;

  // Construir un nombre de archivo que se vea como "/photo_0001.jpg"
  String filename = "/photo_";
  if (number < 1000) filename += "0";
  if (number < 100) filename += "0";
  if (number set_brightness(s, 0);                // -2 a 2
    s->set_contrast(s, 0);                  // -2 a 2
    s->set_saturation(s, 0);                // -2 a 2
    s->set_special_effect(s, 0);            // 0 a 6 (0 - Sin efecto)
    s->set_whitebal(s, 1);                  // 0 = desactivado , 1 = activado
    s->set_awb_gain(s, 1);                  // 0 = desactivado , 1 = activado
    s->set_wb_mode(s, 0);                   // 0 a 4 - si se activa el awb_gain
    s->set_exposure_ctrl(s, 1);             // 0 = desactivado , 1 = activado
    s->set_aec2(s, 0);                       // 0 = desactivado , 1 = activado
    s->set_ae_level(s, 0);                  // -2 a 2
    s->set_aec_value(s, 300);               // 0 a 1200
    s->set_gain_ctrl(s, 1);                 // 0 = desactivado , 1 = activado
    s->set_agc_gain(s, 0);                  // 0 a 30
    s->set_gainceiling(s, (gainceiling_t)0); // 0 a 6
    s->set_bpc(s, 0);                       // 0 = desactivado , 1 = activado
    s->set_wpc(s, 1);                       // 0 = desactivado , 1 = activado
    s->set_raw_gma(s, 1);                   // 0 = desactivado , 1 = activado
    s->set_lenc(s, 1);                      // 0 = desactivado , 1 = activado
    s->set_hmirror(s, 0);                   // 0 = desactivado , 1 = activado
    s->set_vflip(s, 0);                     // 0 = desactivado , 1 = activado
    s->set_dcw(s, 1);                       // 0 = desactivado , 1 = activado
    s->set_colorbar(s, 0);                  // 0 = desactivado , 1 = activado
  }
}

void takePhoto(String filename) {
  digitalWrite(FLASH_LED_PIN, HIGH);
  Serial.println("Tomando foto...");
  camera_fb_t *fb = NULL;

  // Intentar tomar la foto con reintentos
  for (int retry = 0; retry len);

  // Guardar foto en tarjeta SD
  fs::FS &fs = SD_MMC;
  Serial.printf("Nombre del archivo de la foto: %sn", filename.c_str());

  File file = fs.open(filename.c_str(), FILE_WRITE);
  if (!file) {
    Serial.println("Fallo al abrir el archivo en modo escritura");
    esp_camera_fb_return(fb);
    return;
  }

  // Escribir archivo en fragmentos para evitar problemas de memoria
  size_t totalBytes = fb->len;
  size_t bytesWritten = 0;
  const size_t chunkSize = 1024;  // Escribir en fragmentos de 1KB

  while (bytesWritten buf + bytesWritten, toWrite);
    if (written != toWrite) {
      Serial.println("Ocurrió un error de escritura");
      break;
    }
    bytesWritten += written;
  }

  file.close();

  if (bytesWritten == totalBytes) {
    Serial.printf("Archivo guardado en la ruta: %s (%zu bytes)n", filename.c_str(), bytesWritten);
    Serial.println("¡Foto guardada exitosamente!");
  } else {
    Serial.printf("Escritura de archivo incompleta: %zu/%zu bytesn", bytesWritten, totalBytes);
  }

  // Devolver el búfer de imagen inmediatamente después de usarlo
  esp_camera_fb_return(fb);
}

Explicación del código

El código comienza incluyendo varias bibliotecas:

• La biblioteca esp_camera.h nos permite controlar la cámara del ESP32-CAM, incluyendo todas las herramientas necesarias para tomar fotos, ajustar configuraciones de la cámara, y trabajar con datos de imágenes.
• La biblioteca Arduino.h incluye funciones básicas como delay(), Serial.print(), y otras que utilizamos en casi todos los programas de Arduino.
• La biblioteca FS.h nos proporciona comandos para leer y escribir archivos en la tarjeta SD.
• La biblioteca SD_MMC.h facilita el trabajo con tarjetas SD usando la interfaz SD_MMC, que es cómo el ESP32-CAM se comunica con su ranura para microSD.
• Las bibliotecas soc.h y rtc_cntl_reg.h nos permiten desactivar el detector de brownout, que puede causar reinicios no deseados cuando la tensión de la placa cae un poco.
• La biblioteca rtc_io.h ayuda a controlar los pines RTC (Real Time Clock), lo cual es útil cuando queremos mantener GPIOs durante el sueño profundo, como mantener apagado el LED flash.

Se definen algunas constantes, siendo MINUTES_BETWEEN_PHOTOS el intervalo de tiempo (en minutos) entre cada captura de foto, establecido en 30 minutos.

Grabación del time-lapse

Una vez que hayas subido el código a tu ESP32-CAM, desconecta el módulo, inserta la tarjeta micro SD y vuelve a conectarlo. Espera dos segundos y, si todo está bien, verás que el LED blanco parpadea una vez, indicando que se ha guardado una foto en la tarjeta. A menos que hayas cambiado el tiempo de captura, la próxima foto se tomará en media hora.

Antes de comenzar a grabar tu time-lapse, hagamos una rápida verificación. Retira la tarjeta SD de la cámara y colócala en tu computadora. Asegúrate de que puedas ver un archivo de foto llamado “photo_0001.jpg” en la tarjeta. Si está allí, ¡estás listo para comenzar!

Ahora, coloca tu ESP32-CAM en la ubicación deseada y conéctalo a un cargador USB. Espera a que el LED parpadee una vez, confirmando que se capturó la primera imagen. ¡Ahora puedes dejarlo grabando durante el tiempo que desees!

Recuerda que cada vez que retires y vuelvas a insertar la tarjeta SD, necesitarás cortar la alimentación del ESP32-CAM para comenzar una nueva grabación. Simplemente desconecta y vuelve a conectar el cable o cargador, y observa el parpadeo del LED para saber que está funcionando.

Creación del vídeo

Cuando hayas recopilado suficientes imágenes para crear tu time-lapse, retira la tarjeta SD del ESP32-CAM y transfiere los archivos a tu computadora.

Luego, puedes utilizar software de edición de vídeo para ensamblar las imágenes en un vídeo final. Existen varias opciones disponibles, desde herramientas avanzadas como FFmpeg y OpenShot hasta editores de vídeo en línea más simples. Elige el que mejor se adapte a tus necesidades y nivel de habilidad, ¡y deja que la magia del time-lapse se despliegue!

Explorando más allá

Si bien este proyecto muestra una forma sencilla de crear un time-lapse utilizando el ESP32-CAM, hay varias maneras de mejorarlo aún más.

Por ejemplo, podrías modificar el código para poner al ESP32-CAM en modo de sueño profundo entre capturas, despertándose solo cuando es el momento de tomar una foto. Esto reduciría significativamente el consumo de energía, haciendo que tu configuración de time-lapse sea más portátil y amigable con las baterías.

Otra idea sería aprovechar las capacidades inalámbricas del ESP32-CAM para agregar una interfaz web. Esta interfaz podría permitirte descargar imágenes de forma remota o incluso usar tu smartphone como visor. De esta manera, podrías encuadrar fácilmente tu sujeto durante la configuración sin necesidad de retirar la tarjeta SD y comenzar de nuevo cada vez.