ESP32-CAM Tomar foto y guardar en tarjeta MicroSD

La ESP32-CAM es una potente placa de desarrollo que combina funcionalidades de WiFi y cámara, ideal para proyectos de IoT y videovigilancia. En este artículo, aprenderás cómo utilizarla para tomar fotos y guardarlas en una tarjeta MicroSD. ¡Sigue leyendo para descubrir cómo aprovechar al máximo esta increíble tecnología!

Aprenda a tomar fotografías con la placa CAM ESP32 y guardarlas en una tarjeta microSD usando el IDE de Arduino. Cuando presiones el botón ESP32 CAM RESET, se activará, tomará una foto y la guardará en la tarjeta microSD.

ESP32-CAM Tomar foto y guardar en tarjeta MicroSD

Estamos utilizando la placa CAM ESP32 llamada Módulo AI Thinker, pero otros módulos también deberían funcionar si se realiza la asignación de pines correcta en el código.

El Placa de leva ESP32 es un dispositivo de $9 (o menos) que combina un chip ESP32-S, una cámara OV2640, una ranura para tarjeta microSD y múltiples pines GPIO.

ESP32-CAM Tomar foto y guardar en tarjeta MicroSD

Para una introducción a ESP32-CAM puedes seguir los siguientes tutoriales:

  • Streaming de vídeo ESP32 CAM y reconocimiento facial con Arduino IDE
  • Servidor web de transmisión de video ESP32-CAM (funciona con Home Assistant, Node-RED, etc.)
  • Guía de solución de problemas de ESP32-CAM

Mira el vídeotutorial

Para aprender a usar la ESP32 CAM para tomar fotografías y guardarlas en la tarjeta microSD, puede ver el siguiente video tutorial o continuar leyendo esta página para obtener instrucciones escritas y todos los recursos.

Piezas requeridas

Para seguir este tutorial necesitarás los siguientes componentes:

Puedes utilizar los enlaces anteriores o ir directamente MakerAdvisor.com/tools ¡Para encontrar todas las piezas para tus proyectos al mejor precio!

ESP32-CAM Tomar foto y guardar en tarjeta MicroSD

Descripción del proyecto

A continuación se ofrece una descripción general rápida de cómo funciona el proyecto.

ESP32-CAM Tomar foto y guardar en tarjeta MicroSD
  • El ESP32-CAM está en modo de suspensión profunda
  • Presione el botón RESET para reactivar la placa.
  • La cámara toma una foto.
  • La foto se guardará en la tarjeta microSD con el nombre: imagenX.jpg, donde X corresponde al número de la imagen.
  • Para que no se borre durante el RESET y estemos atentos al número de imágenes tomadas, el número de imagen se guarda en la memoria flash del ESP32.

Formatear la tarjeta MicroSD

Lo primero que te recomendamos hacer es formatear tu tarjeta microSD. Puede utilizar Windows Format Tool u otro software de formateo de microSD.

1. Inserta la tarjeta microSD en tu computadora. Ir a Mi computadora y haga clic derecho en la tarjeta SD. Elegir formato como se muestra en la siguiente figura.

ESP32-CAM Tomar foto y guardar en tarjeta MicroSD

2. Una nueva ventana se abrirá. Elegir FAT32Prensa comenzar para inicializar el proceso de formateo y siga las instrucciones que aparecen en pantalla.

ESP32-CAM Tomar foto y guardar en tarjeta MicroSD

Nota: Según las especificaciones del producto, el ESP32-CAM sólo debería admitir tarjetas SD de 4 GB. Sin embargo, lo probamos con una tarjeta SD de 16 GB y funciona bien.

Instalación del complemento ESP32

Programamos la placa ESP32 usando Arduino IDE. Por lo tanto, debe tener instalados tanto el IDE de Arduino como el complemento ESP32. Puede seguir el siguiente tutorial para instalar el complemento ESP32 si aún no lo ha hecho:

  • Instalación de la placa ESP32 en Arduino IDE 2 (Windows, Mac OS X, Linux)

Tomar y guardar un boceto fotográfico.

Copie el siguiente código en su IDE de Arduino.

/*********
  Rui Santos
  Complete project details at https://RandomNerdTutorials.com/esp32-cam-take-photo-save-microsd-card
  
  IMPORTANT!!! 
   - Select Board "AI Thinker ESP32-CAM"
   - GPIO 0 must be connected to GND to upload a sketch
   - After connecting GPIO 0 to GND, press the ESP32-CAM on-board RESET button to put your board in flashing mode
  
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files.
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
*********/

#include "esp_camera.h"
#include "Arduino.h"
#include "FS.h"                // SD Card ESP32
#include "SD_MMC.h"            // SD Card ESP32
#include "soc/soc.h"           // Disable brownour problems
#include "soc/rtc_cntl_reg.h"  // Disable brownour problems
#include "driver/rtc_io.h"
#include <EEPROM.h>            // read and write from flash memory

// define the number of bytes you want to access
#define EEPROM_SIZE 1

// 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

int pictureNumber = 0;

void setup() {
  WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0); //disable brownout detector
 
  Serial.begin(115200);
  //Serial.setDebugOutput(true);
  //Serial.println();
  
  camera_config_t config;
  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_ + QVGA|CIF|VGA|SVGA|XGA|SXGA|UXGA
    config.jpeg_quality = 10;
    config.fb_count = 2;
  } else {
    config.frame_size = FRAMESIZE_SVGA;
    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;
  }
  
  //Serial.println("Starting SD Card");
  if(!SD_MMC.begin()){
    Serial.println("SD Card Mount Failed");
    return;
  }
  
  uint8_t cardType = SD_MMC.cardType();
  if(cardType == CARD_NONE){
    Serial.println("No SD Card attached");
    return;
  }
    
  camera_fb_t * fb = NULL;
  
  // Take Picture with Camera
  fb = esp_camera_fb_get();  
  if(!fb) {
    Serial.println("Camera capture failed");
    return;
  }
  // initialize EEPROM with predefined size
  EEPROM.begin(EEPROM_SIZE);
  pictureNumber = EEPROM.read(0) + 1;

  // Path where new picture will be saved in SD Card
  String path = "/picture" + String(pictureNumber) +".jpg";

  fs::FS &fs = SD_MMC; 
  Serial.printf("Picture file name: %sn", path.c_str());
  
  File file = fs.open(path.c_str(), FILE_WRITE);
  if(!file){
    Serial.println("Failed to open file in writing mode");
  } 
  else {
    file.write(fb->buf, fb->len); // payload (image), payload length
    Serial.printf("Saved file to path: %sn", path.c_str());
    EEPROM.write(0, pictureNumber);
    EEPROM.commit();
  }
  file.close();
  esp_camera_fb_return(fb); 
  
  // Turns off the ESP32-CAM white on-board LED (flash) connected to GPIO 4
  pinMode(4, OUTPUT);
  digitalWrite(4, LOW);
  rtc_gpio_hold_en(GPIO_NUM_4);
  
  delay(2000);
  Serial.println("Going to sleep now");
  delay(2000);
  esp_deep_sleep_start();
  Serial.println("This will never be printed");
}

void loop() {
  
}

Ver código sin formato

El código comienza integrando las bibliotecas necesarias para usar la cámara. También incluimos las bibliotecas necesarias para interactuar con la tarjeta microSD:

#include "esp_camera.h"
#include "Arduino.h"
#include "FS.h"                // SD Card ESP32
#include "SD_MMC.h"            // SD Card ESP32
#include "soc/soc.h"           // Disable brownour problems
#include "soc/rtc_cntl_reg.h"  // Disable brownour problems
#include "driver/rtc_io.h"
#include <EEPROM.h>            // read and write from flash memory

Y eso EEPROM Biblioteca para almacenar datos persistentes en memoria flash.

#include <EEPROM.h>

Si quieres aprender más sobre cómo leer y escribir datos desde la memoria flash, puedes seguir el siguiente tutorial:

  • Memoria flash ESP32: almacena datos permanentemente (escritura y lectura)

Determine cuántos bytes de memoria flash desea recuperar. Aquí solo utilizamos un byte, lo que nos permite generar hasta 256 números de imagen.

#define EEPROM_SIZE 1

Luego defina los pines para el módulo de cámara AI-THINKER.

// 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

Nota: Dependiendo de la tarjeta que esté utilizando, es posible que deba cambiar la definición del PIN. La asignación incorrecta de pines provocará que la cámara no se inicialice.

Inicializar una variable int llamada Número de imagen Esto generará el nombre de la foto: Imagen1.jpg, Imagen2.jpg, etc.

int pictureNumber = 0;

Todo nuestro código está en el configuración(). El código solo se ejecuta una vez cuando el ESP32 se activa (en este caso, cuando presiona el botón RESET integrado).

Defina la configuración de la cámara:

camera_config_t config;
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; 

Utilice las siguientes configuraciones para una cámara con PSRAM (como la que usamos en este tutorial).

if(psramFound()){
  config.frame_size = FRAMESIZE_UXGA; // FRAMESIZE_ + QVGA|CIF|VGA|SVGA|XGA|SXGA|UXGA
  config.jpeg_quality = 10;
  config.fb_count = 2;
}

Si la tarjeta no tiene PSRAM, configure lo siguiente:

else {
  config.frame_size = FRAMESIZE_SVGA;
  config.jpeg_quality = 12;
  config.fb_count = 1;
}

Inicialice la cámara:

// 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;
}

Inicialice la tarjeta microSD:

//Serial.println("Starting SD Card");
if(!SD_MMC.begin()){
  Serial.println("SD Card Mount Failed");
  return;
}
 
uint8_t cardType = SD_MMC.cardType();
if(cardType == CARD_NONE){
  Serial.println("No SD Card attached");
  return;
}

Para obtener más información sobre el uso de la tarjeta microSD, consulte el siguiente proyecto:

  • Temperatura de registro de datos ESP32 a la tarjeta MicroSD

Las siguientes líneas toman una foto con la cámara:

camera_fb_t * fb = NULL;

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

Luego inicialice la EEPROM con el tamaño previamente definido:

EEPROM.begin(EEPROM_SIZE);

El número de imagen se obtiene sumando 1 al número actualmente almacenado en la memoria flash.

pictureNumber = EEPROM.read(0) + 1;

Para guardar la foto en la tarjeta microSD, cree una ruta a su archivo. Guardamos la foto en el directorio raíz de la tarjeta microSD y el nombre del archivo es (Imagen1.jpg, Imagen2.jpg, Imagen3.jpg, etc.).

String path = "/picture" + String(pictureNumber) +".jpg";

Las siguientes líneas guardan la foto en la tarjeta microSD:

fs::FS &fs = SD_MMC; 
Serial.printf("Picture file name: %sn", path.c_str());

File file = fs.open(path.c_str(), FILE_WRITE);
if(!file){
  Serial.println("Failed to open file in writing mode");
} 
else {
  file.write(fb->buf, fb->len); // payload (image), payload length
  Serial.printf("Saved file to path: %sn", path.c_str());
  EEPROM.write(0, pictureNumber);
  EEPROM.commit();
}
file.close();

Después de guardar una foto, guardamos el número de imagen actual en la memoria flash para realizar un seguimiento de la cantidad de fotos tomadas.

EEPROM.write(0, pictureNumber);
EEPROM.commit();

Cuando el ESP32-CAM toma una foto, el LED integrado parpadea. Después de tomar la foto, el LED permanecerá encendido, por lo que enviaremos instrucciones para apagarlo. El LED está conectado a GPIO 4.

pinMode(4, OUTPUT);
digitalWrite(4, LOW);
rtc_gpio_hold_en(GPIO_NUM_4);

Finalmente, ponemos el ESP32 en sueño profundo.

esp_deep_sleep_start();

Como no pasamos un argumento a la función de suspensión profunda, la placa ESP32 duerme indefinidamente hasta RESET.

Código de carga de cámara ESP32

Para cargar código a la placa CAM ESP32, conéctela a su computadora usando un programador FTDI. Siga el siguiente diagrama esquemático:

ESP32-CAM Tomar foto y guardar en tarjeta MicroSD

Muchos programadores FTDI tienen un puente que le permite seleccionar 3,3 V o 5 V. Asegúrese de que el puente esté en el lugar correcto para seleccionar 5V.

Importante: GPIO 0 debe estar conectado a Dimensiones para que puedas subir el código.

Leva ESP32 programador FTDI
Dimensiones Dimensiones
5V VCC (5V)
U0R Texas
U0T RX
GPIO 0 Dimensiones

Para cargar el código, siga los siguientes pasos:

1) Ir a Herramientas > tablón y elige Pensador de IA ESP32-CAM.

2) Ir a Herramientas > Puerto y seleccione el puerto COM al que está conectado el ESP32.

3) Luego haga clic en el botón «Cargar» para cargar el código.

ESP32-CAM Tomar foto y guardar en tarjeta MicroSD

4) Cuando vea estos puntos en la ventana de depuración como se muestra a continuación, presione el botón RST incorporado del ESP32-CAM.

ESP32-CAM Tomar foto y guardar en tarjeta MicroSD

Después de unos segundos, el código debería cargarse correctamente en su tablero.

demostración

Después de cargar el código, retire el puente que conecta GPIO 0 a GND.

Abra el monitor serie con una velocidad de baudios de 115200. Presione el botón de reinicio del ESP32-CAM. El dispositivo debería inicializarse y tomar una foto. Cuando se toma una foto, el flash se enciende (GPIO 4).

ESP32-CAM Tomar foto y guardar en tarjeta MicroSD

Verifique la ventana Arduino IDE Serial Monitor para ver si todo funciona como se esperaba. Como puede ver, la imagen se guardó correctamente en la tarjeta microSD.

ESP32-CAM Tomar foto y guardar en tarjeta MicroSD

Nota: Si tiene problemas con ESP32-CAM, consulte nuestra guía de solución de problemas y vea si le ayuda: Guía de solución de problemas de ESP32-CAM: solución de los problemas más comunes

Después de asegurarte de que todo funciona como se esperaba, puedes desconectar el ESP32 CAM del programador FTDI y alimentarlo desde una fuente de alimentación independiente.

ESP32-CAM Tomar foto y guardar en tarjeta MicroSD

Para ver las fotos que tomó, retire la tarjeta microSD de la ranura para tarjetas microSD e insértela en su computadora. Deberías haber guardado todas las fotos.

ESP32-CAM Tomar foto y guardar en tarjeta MicroSD

La calidad de tu foto depende de tus condiciones de iluminación. Demasiada luz puede arruinar tus fotos y los entornos oscuros generan muchos píxeles negros.

Solución de problemas

Si recibe alguno de los siguientes errores, consulte nuestra Guía de solución de problemas de ESP32-CAM: solución de los problemas más comunes

  • No se pudo conectar a ESP32: tiempo de espera de espera para el encabezado del paquete
  • La inicialización de la cámara falló con el error 0x20001 o similar
  • Detector de caída de tensión o error de meditación del gurú
  • Error de boceto demasiado grande: se seleccionó un esquema de partición incorrecto
  • La tarjeta en COMX no está disponible – Puerto COM no seleccionado
  • Error de Psram: el servicio GPIO ISR no está instalado
  • Señal WiFi débil
  • No hay dirección IP en el monitor serie Arduino IDE
  • No se puede abrir el servidor web
  • La imagen está retrasada/muestra una latencia alta.

ESP32-CAM Tomar foto y guardar en tarjeta MicroSD

[eBook] Crea proyectos CAM ESP32 con Arduino IDE

Aprenda a programar y crear proyectos con ESP32-CAM usando Arduino IDE 17 DESCARGAR «

Aprenda a programar y crear proyectos con ESP32-CAM usando Arduino IDE 17 DESCARGAR «

Envolver

Esperamos que este tutorial te haya resultado útil y puedas utilizarlo en tus proyectos. Si no tienes una placa CAM ESP32, puedes Pulsa aquí para conseguir uno.

Como se mencionó, tenemos otros tutoriales de ESP32 CAM que te pueden gustar:

  • Streaming de vídeo ESP32 CAM y reconocimiento facial con Arduino IDE
  • Servidor web de transmisión de video ESP32-CAM (funciona con Home Assistant)
  • ESP32-CAM Detector de movimiento PIR con grabación de fotografías (guarda en tarjeta microSD)
  • ESP32-CAM toma fotografías y las muestra en el servidor web
  • Descripción rápida: ESP32-CAM con cámara OV2640
  • ¿Dónde puedes comprar el ESP32-CAM?
  • Crear proyectos ESP32-CAM (libro electrónico)
  • Lea todos nuestros proyectos, tutoriales y guías de ESP32 CAM

Gracias por leer.

Error 403 The request cannot be completed because you have exceeded your quota. : quotaExceeded

Tomar foto con ESP32-CAM y guardar en tarjeta MicroSD

Aprende cómo tomar fotos con la placa ESP32-CAM y guardarlas en una tarjeta microSD utilizando Arduino IDE. Cuando presionas el botón de RESET de ESP32-CAM, este se activa, toma una foto y la guarda en la tarjeta microSD.

Placa ESP32-CAM

Estaremos utilizando la placa ESP32-CAM etiquetada como módulo AI-Thinker, pero otros módulos también deberían funcionar haciendo la asignación de pines correcta en el código.

La placa ESP32-CAM es un dispositivo de $9 (o menos) que combina un chip ESP32-S, una cámara OV2640, un slot para tarjeta microSD y varios pines GPIO.

Partes Necesarias

Para seguir este tutorial, necesitarás los siguientes componentes:

  1. ESP32-CAM con OV2640
  2. Tarjeta microSD
  3. Programador FTDI
  4. Cables de puente hembra a hembra
  5. Fuente de alimentación de 5V para ESP32-CAM o batería portátil (opcional)

Puedes encontrar todos los componentes necesarios en MakerAdvisor.com/tools

Resumen del Proyecto

Aquí tienes un resumen rápido de cómo funciona el proyecto:

  1. ESP32-CAM está en modo de reposo profundo
  2. Presiona el botón RESET para despertar la placa
  3. La cámara toma una foto
  4. La foto se guarda en la tarjeta microSD con el nombre: pictureX.jpg, donde X corresponde al número de la foto
  5. El número de la foto se guarda en la memoria flash de ESP32 para llevar un registro

Formatear la Tarjeta MicroSD

Lo primero que recomendamos hacer es formatear tu tarjeta microSD. Puedes utilizar la herramienta de formateo de Windows u otro software de formateo de microSD.

  1. Inserta la tarjeta microSD en tu computadora. Ve a Mi PC, haz clic derecho en la tarjeta SD y selecciona Formatear.
  2. Una nueva ventana se abrirá. Selecciona FAT32, presiona Iniciar para iniciar el proceso de formateo y sigue las instrucciones en pantalla.

Según las especificaciones del producto, ESP32-CAM debería admitir solo tarjetas SD de 4 GB. Sin embargo, hemos probado con una tarjeta SD de 16 GB y funciona bien.

Instalación del Complemento ESP32

Programaremos la placa ESP32 utilizando Arduino IDE. Entonces necesitas tener instalado Arduino IDE y el complemento ESP32. Puedes seguir el siguiente tutorial para instalar el complemento ESP32, si aún no lo has hecho:

Instalación de Placa ESP32 en Arduino IDE

Código para Tomar y Guardar Foto

Copia el siguiente código a tu Arduino IDE. Este código te permitirá tomar una foto con ESP32-CAM y guardarla en la tarjeta microSD.

Inserta aquí el código HTML del programa...

Para ver el código completo y más detalles técnicos, visita el tutorial completo en RandomNerdTutorials.com.

Subir Código a la ESP32-CAM

Para subir el código a la placa ESP32-CAM, conéctala a tu computadora utilizando un programador FTDI. Sigue el esquema de conexión indicado en el tutorial.

Para subir el código, sigue los siguientes pasos:

  1. Ve a Herramientas > Placa y selecciona AI-Thinker ESP32-CAM.
  2. Ve a Herramientas > Puerto y selecciona el puerto COM al que está conectado ESP32.
  3. Luego, haz clic en el botón de cargar para subir el código.

Después de unos segundos, el código debería subirse correctamente a tu placa.

Conclusiones

Esperamos que este tutorial te haya sido útil y puedas aplicarlo en tus proyectos. Si aún no tienes una placa ESP32-CAM, puedes adquirir una haciendo clic en el siguiente enlace.

Para más información y tutoriales sobre ESP32-CAM, no dudes en visitar RandomNerdTutorials.com.

4 comentarios en «ESP32-CAM Tomar foto y guardar en tarjeta MicroSD»

Deja un comentario