Assista no YouTube

Tutorial ESP32 42/55 - Tirando Foto com Câmera salva no Micro SD CAM-1 | Kit ESP32 da SunFounder

Neste tutorial, usaremos o microcontrolador ESP32 juntamente com sua placa de expansão da SunFounder para capturar fotos usando uma câmera e salvá-las diretamente em um cartão micro SD. Este projeto utiliza as capacidades integradas do ESP32, incluindo Wi-Fi e Bluetooth, para criar um dispositivo compacto de captação de fotos. Ao final deste tutorial, você terá uma configuração funcional que pode tirar e armazenar imagens, que poderão ser acessadas posteriormente em um computador.

Para aqueles que são novos no ecossistema ESP32, este kit fornece uma plataforma versátil para vários projetos, incluindo este. A câmera usada neste projeto é a OV2640, que oferece uma resolução de 1600x1200 pixels. Embora não corresponda à qualidade dos smartphones modernos, é suficiente para tarefas básicas de captura de imagem. Para esclarecer quaisquer etapas, certifique-se de verificar o vídeo que acompanha este tutorial (no vídeo em 00:00).

Hardware Explicado

Os componentes principais deste projeto incluem o microcontrolador ESP32, o módulo da câmera (OV2640) e um cartão micro SD para armazenamento. O ESP32 é um microcontrolador poderoso com capacidades integradas de Wi-Fi e Bluetooth, tornando-o ideal para aplicações de IoT. O módulo da câmera captura imagens, que são então processadas pelo ESP32.

O cartão micro SD atua como um meio de armazenamento para as imagens capturadas. Nesta configuração, o ESP32 se comunica com o módulo da câmera usando pinos GPIO específicos, e as imagens são salvas em formato JPEG no cartão SD. Isso permite a fácil recuperação e visualização das fotos posteriormente.

• Certifique-se de que a câmera está corretamente orientada ao inserir na placa ESP32.
• Use um cartão micro SD com capacidade de 32 GB ou menos para evitar problemas de compatibilidade.
• Conecte o GPIO 0 ao GND para o modo de programação.
• Preste atenção na alimentação elétrica para evitar problemas de quedas de tensão.
• Mantenha a câmera estável ao tirar fotos para evitar imagens borradas.

Instruções de fiação

Para conectar o módulo de câmera ESP32, primeiro certifique-se de que o ESP32 está desligado. Conecte o módulo de cartão micro SD ao ESP32 usando os seguintes pinos: conecte oCSpino do cartão SD para o ESP32GPIO 5,MOSIparaGPIO 23,MISOparaGPIO 19, eSCKparaGPIO 18. Em seguida, conecte os pinos do módulo da câmera da seguinte forma:PWDNparaGPIO 32,XCLKparaGPIO 0,SIODparaGPIO 26, eSIOCparaGPIO 27Os pinos dos dados de pixelY2paraY9deve estar conectado aGPIO 5atravésGPIO 39conforme definido em seu código.

Certifique-se de conectar os pinos de terra e de energia adequadamente. O ESP32 pode ser alimentado pela bateria incluída no kit. Após a fiação, verifique se as conexões estão seguras antes de ligar o dispositivo. Se você seguir as instruções cuidadosamente, deverá ver a câmera inicializar corretamente quando você carregar o código.

Exemplos de Código e Passo a Passo

No texto, começamos incluindo as bibliotecas necessárias e definindo as configurações dos pinos da câmera. A variávelpictureNumberé inicializado para acompanhar o número de fotos tiradas.

int pictureNumber = 0;

void setup() {
  WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0);  // Disable brownout detector
  Serial.begin(115200);
  camera_config_t config;
  // Configuration settings for the camera
  config.ledc_channel = LEDC_CHANNEL_0;
  // Additional camera settings...
}

A função de configuração inicializa a comunicação serial e configura as definições da câmera. A configuração inclui parâmetros comoledc_channel,pin_d0, exclk_freq_hzpara desempenho ideal.

Em seguida, lidamos com o processo de captura de imagem usando um loop para tirar várias fotos. Os dados das imagens são salvos no cartão SD com um nome de arquivo baseado nopictureNumber.

for (int shoot = 0; shoot < 5; shoot++) {
    camera_fb_t *fb = esp_camera_fb_get(); // Take Picture
    String path = "/picture" + String(pictureNumber) + ".jpg"; // File path
    File file = fs.open(path.c_str(), FILE_WRITE); // Open file to write
    // Write image data to file
    file.write(fb->buf, fb->len);
    // Update picture number in EEPROM
    EEPROM.write(0, pictureNumber);
}

Este loop captura até cinco imagens, onde cada imagem é salva com um nome de arquivo exclusivo. O uso de EEPROM permite que o programa lembre do último número da foto, garantindo que cada nova imagem tenha um identificador exclusivo.

Demonstração / O que Esperar

Quando você executar o código, o ESP32 irá inicializar a câmera e o cartão SD. Após pressionar o botão de reset no ESP32, ele tirará uma série de fotos, que serão numeradas sequencialmente de 0 a 255 com base no valor da EEPROM. Após capturar as imagens, você pode remover o cartão micro SD e visualizar as fotos no seu computador.

Erros comuns incluem garantir que o cartão micro SD esteja formatado e inserido corretamente, assim como manter uma posição estável da câmera para evitar imagens embaçadas. Se você encontrar problemas com a câmera não capturando imagens, cheque novamente a fiação e as configurações definidas no código (no vídeo às 06:45).

Marcos de vídeo

• 00:00 Início
• 1:39 Introdução
• 5:19 Código da Câmera ESP32 explicado
• 11:10 Selecionando a placa ESP32 e a porta COM no Arduino IDE
• 12:52 Testando fotos internas e externas

Imagens

esp32-41-setting-3

extension_bopard_camera

20240103_163227858_iOS

esp32-41-setting-1

esp32-41-setting-2

esp32-41-setting-3

extension_bopard_camera

20240103_163227858_iOS

esp32-41-setting-1

esp32-41-setting-2

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

  // initialize EEPROM with predefined size
  EEPROM.begin(EEPROM_SIZE);
  pictureNumber = EEPROM.read(0) + 1;

  for (int shoot = 0; shoot < 5; shoot++) {
    camera_fb_t *fb = NULL;

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

    // 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: %s\n", 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);  // Write image data to file
      if (shoot == 4) {
        Serial.printf("Saved file to path: %s\n", path.c_str());
      }else{
        Serial.printf("Shooting... \n");
      }
      EEPROM.write(0, pictureNumber);  // Update the picture number in EEPROM
      EEPROM.commit();
    }
    file.close();                      // Close the file
    esp_camera_fb_return(fb);          // Return the frame buffer back to the camera driver
    delay(200);                        // Short delay between shots
  }
  // 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);

  // Put the ESP32-CAM to deep sleep
  delay(2000);
  Serial.println("Going to sleep now");
  delay(2000);
  esp_deep_sleep_start();
  Serial.println("This will never be printed");
}

void loop() {
  // Empty loop as we are putting the ESP32-CAM to deep sleep
}