Subir fotos a un servidor FTP con ESP32-CAM

ESP32-CAM es un excelente dispositivo para utilizarlo para generar timelapse, tanto por su tamaño como por su precio.

Uno de los temas que se debe resolver al trabajar con los timelapse, es el almacenamiento de las fotografías que obtenemos. Si bien el ESP32-CAM tiene la posibilidad de almacenar las fotografías en una tarjeta de memoria, la conveniencia de que las suba automáticamente a un servidor FTP simplifica mucho la tarea.

En este articulo vemos como realizar esta tarea de manera extremadamente simple, gracias a la librería ESP32_FTPClient

La misma permite varias operaciones con el servidor FTP, entre las que se encuentra cambiar de carpeta, listar el contenido, subir y descargar archivos. Nos enfocaremos en subir un archivo, que sera la fotografía que hayamos obtenido.

Comenzaremos descargando e instalando la librería mencionada en el IDE de Arduino. Para ello una vez que se haya descargado el archivo, vamos al menú Programa – Incluir Liberia – Añadir Liberia .ZIP y seleccionamos el archivo que descargamos.

A continuación, se detalle como funciona:

#include "esp_camera.h"
#include "soc/soc.h"           // Disable brownour problems
#include "soc/rtc_cntl_reg.h"  // Disable brownour problems
#include "driver/rtc_io.h"
#include <WiFi.h>
#include <WiFiClient.h>   
#include "ESP32_FTPClient.h"

#include <NTPClient.h> //For request date and time
#include <WiFiUdp.h>
#include "time.h"

char* ftp_server = "SERVER";
char* ftp_user = "USER";
char* ftp_pass = "PASSWORD";
char* ftp_path = "/USER/;

const char* WIFI_SSID = "NETWORK";
const char* WIFI_PASS = "PASSWORD";

WiFiUDP ntpUDP;
NTPClient timeClient(ntpUDP, "pool.ntp.org", (-3600*3), 60000);

ESP32_FTPClient ftp (ftp_server,ftp_user,ftp_pass, 5000, 2);

Ademas de importar las librerías dedicadas a la cámara y a operación de las redes wifi, también necesitamos importar la nueva librería para trabajar con FTP.

NTPClient nos permite consultar la fecha y la hora, uno de los parámetros que le pasamos es la diferencia horaria, expresado en segundos; en mi caso son -3 horas por lo que se pasa como parámetro (-3600*3).

Incorpore dos funciones a la libreria NTPClient para que sea mas sencilla de tomar los datos de fecha/hora y poder utilizarlos en este caso, pueden descargar aquí.

Luego instanciamos las variables que contendrán los datos del servidor ftp, así como usuario/clave y la ruta donde subiremos el archivo.

// Pin definition for 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

camera_config_t config;

Se definen los GPIO que seran utilizados para la cámara y la variable config, que utilizaremos para configurar los parametros de la cámara.

void setup() {
  WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0); //disable brownout detector
 
  Serial.begin(115200);

  WiFi.begin(WIFI_SSID, WIFI_PASS);
  
  Serial.println("Connecting Wifi...");
  while (WiFi.status() != WL_CONNECTED) {
      delay(500);
      Serial.println("Connecting to WiFi..");
      
  }
  Serial.println("IP address: ");
      
  Serial.println(WiFi.localIP());

  initCamera();

  timeClient.begin();
  timeClient.update();

  ftp.OpenConnection();
}

En setup(), ademas de las clásicas rutinas se llama a initCamera(), que inicializara la cámara (se lo hace de esta manera para separar el código en bloques y que sea mas fácil la lectura); y luego se abre la conexión con el servidor FTP; esto podría hacerse en el momento de subir el archivo, pero se realiza en este punto para mejorar los tiempos entre cada imagen.

void initCamera() {
  config.ledc_channel = LEDC_CHANNEL_0;
  config.ledc_timer = LEDC_TIMER_0;
  config.pin_d0 = Y2_GPIO_NUM;
  config.pin_d1 = Y3_GPIO_NUM;
  config.pin_d2 = Y4_GPIO_NUM;
  config.pin_d3 = Y5_GPIO_NUM;
  config.pin_d4 = Y6_GPIO_NUM;
  config.pin_d5 = Y7_GPIO_NUM;
  config.pin_d6 = Y8_GPIO_NUM;
  config.pin_d7 = Y9_GPIO_NUM;
  config.pin_xclk = XCLK_GPIO_NUM;
  config.pin_pclk = PCLK_GPIO_NUM;
  config.pin_vsync = VSYNC_GPIO_NUM;
  config.pin_href = HREF_GPIO_NUM;
  config.pin_sscb_sda = SIOD_GPIO_NUM;
  config.pin_sscb_scl = SIOC_GPIO_NUM;
  config.pin_pwdn = PWDN_GPIO_NUM;
  config.pin_reset = RESET_GPIO_NUM;
  config.xclk_freq_hz = 20000000;
  config.pixel_format = PIXFORMAT_JPEG; 
  
  if(psramFound()){
    config.frame_size = FRAMESIZE_UXGA;//FRAMESIZE_UXGA; // FRAMESIZE_ + QVGA|CIF|VGA|SVGA|XGA|SXGA|UXGA
    config.jpeg_quality = 10;
    config.fb_count = 2;
  } else {
    config.frame_size = FRAMESIZE_UXGA;
    config.jpeg_quality = 12;
    config.fb_count = 1;
  }  
  // Init Camera
  esp_err_t err = esp_camera_init(&config);
  if (err != ESP_OK) {
    Serial.printf("Camera init failed with error 0x%x", err);
    return;
  }  
}

En la función initCamera() inicializamos la cámara con los parámetros establecidos. Podemos cambiar la resolución de las imágenes reemplazando el valor de:

config.frame_size = FRAMESIZE_UXGA;

Por otro tamaño (QVGA|CIF|VGA|SVGA|XGA|SXGA|UXGA):


config.frame_size = FRAMESIZE_VGA; //para bajar la resolución de las imágenes
void loop() {
  timeClient.update();
  takePhoto();
  delay(60000);
}

En la función loop() solo tenemos dos acciones, tomar la fotografía con takePhoto() y esperar por 60 segundos.

void takePhoto() {
   
  camera_fb_t * fb = NULL;
  
  // Take Picture with Camera
  fb = esp_camera_fb_get();  
  if(!fb) {
    Serial.println("Camera capture failed");
    return;
  }

  /*
   * Upload to ftp server
   */
  ftp.ChangeWorkDir(ftp_path);
  ftp.InitFile("Type I");
  
  String nombreArchivo = timeClient.getFullFormattedTimeForFile()+".jpg";
  Serial.println("Subiendo "+nombreArchivo);
  int str_len = nombreArchivo.length() + 1; 
 
  char char_array[str_len];
  nombreArchivo.toCharArray(char_array, str_len);
  
  ftp.NewFile(char_array);
  ftp.WriteData( fb->buf, fb->len );
  ftp.CloseFile();
  
  /*
   * Free buffer
   */
  esp_camera_fb_return(fb); 
}

En la función takePhoto() se realizan tres operaciones: primero se toma una fotografía y se mantiene en el buffer fb.

En estas cinco lineas se realiza la subida al servidor ftp; primero cambiamos el directorio al directorio de trabajo, especificado en la variable ftp_path.

timeClient.getFullFormattedTimeForFile() nos devuelve un string con la fecha y hora en formato: AAAAMMDD_HHMMSS, concatenamos la extensión .jpg y lo convertimos a un array de char, que es el tipo de datos que toma la función NewFile de ftp.

Escribimos el buffer y cerramos el archivo.

La ultima tarea es liberar el buffer.

Una vez cargado el programa, las imágenes comienzan a subir de inmediato:

Construyendo PanoramicCam

En una entrada anterior comente como trabaja el software de PanoramicCam, pueden encontrarlo aquí.

En este punto me quiero enfocar un poco sobre el hardware utilizado, el cual fue auspiciado por DigitSpace, los links de cada uno de los componentes están debajo:

Comencé cortando una pieza de pcb ligeramente superior al tamaño del ESP32-CAM:

Utilice el soporte impreso para marcar donde irían los agujeros para sujetar el pcb al soporte; cuidado al performar, el pcb puede quebrarse.

Luego posicionamos el ESP32-CAM junto con los headers y lo soldamos en la posición, de manera que quede de la siguiente manera:

Debemos soldar 6 cables sobre el ESP32-CAM; dos son la alimentación que van a 5V y GND, y los cuatro restantes es la comunicación con el ULN2003, van soldados a
GPIO 12,13,15 y 14.

Se utiliza el siguiente esquema de conexiones:

Noten que en la alimentación del ESP32-CAM utilice un condensador, usualmente no lo requiere y funciona correctamente, pero ayudo mucho a prevenir brownout. En mi caso utilice un condensador electrolítico, que era lo que tenia disponible en el momento.

Una vez soldados los cables, podemos comenzar a montar la base del soporte;

El soporte impreso tiene una mueca donde entra el breakout usb, antes de pegarlo a la base, es necesario soldar cuatro cables, dos para los 5V, en mi caso utilice dos tipos de conectores diferentes: uno para conectar la alimentación del ESP32-CAM y otro para conectar el ULN2003.

El pcb del ULN2003 lo atornille al soporte, aunque podría ir simplemente pegado. Si lo pegan tengan cuidado de no aplicar mucho pegamento derretido junto, el calor puede deformar el soporte.

El motor paso a paso va montado sobre el soporte con dos tornillos y tuercas; las tuercas las puse en la parte interior de manera que se sujeten contra el mismo motor y sea sencillo de ajustar.

El soporte impreso no tiene 100% la coincidencia de donde van los tornillos, los volvi a hacer con un taladro y quedo bien. Decidi que el STL no tenga las perforaciones de los tornillos sino que cada uno las haga por su cuenta, de esa manera permite reemplazar el motor por otro.

El link de thingiverse para descargar los modelos es el siguiente:
https://www.thingiverse.com/thing:4270344

El pcb donde tenemos el ESP32-CAM va montado sobre el soporte vertical utilizando un precinto; en mi caso no tenia ningún tornillo de ese diámetro y también previene de sumar mas peso al cabezal.

También utilice un precinto para mantener juntos los cables.

Es importante pasarlos por el orificio del soporte impreso antes de soldar los conectores. Luego sera imposible.

Luego solo resta poner los conectores a los cables, en mi caso emplee de diferente color y los agrupe por bobina con una cinta:

De esta manera tenemos para la bobina 1 en IN1 y IN2 y para la bobina 2 en IN3 y IN4.

Por ultimo debemos organizar un poco los cables y colocar la tapa inferior con dos tornillos.