Mafunzo ya ESP32 42/55 - Kuchukua Picha kwa Kamera na kuihifadhi kwenye Micro SD CAM-1 | Kifurushi cha ESP32 cha SunFounder

Mafunzo ya ESP32 42/55 - Kuchukua Picha kwa Kamera na kuihifadhi kwenye Micro SD CAM-1 | Kifurushi cha ESP32 cha SunFounder

Katika mafunzo haya, tutatumia microcontroller ya ESP32 pamoja na bodi yake ya upanuzi kutoka SunFounder kupiga picha kwa kutumia kamera na kuzihifadhi moja kwa moja kwenye kadi ndogo ya SD. Mradi huu unatumia uwezo wa ndani wa ESP32, ikiwa ni pamoja na Wi-Fi na Bluetooth, kuunda kifaa cha kupiga picha cha kompakt. Kufikia mwisho wa mafunzo haya, utakuwa na mfumo wa kufanya kazi unaoweza kupiga na kuhifadhi picha, ambazo zinaweza kufikiwa baadaye kwenye kompyuta.

Kwa wale ambao ni wapya kwenye mfumo wa ESP32, kit hiki hutoa jukwaa linaloweza kutumika kwa miradi mbalimbali, ikiwa ni pamoja na hii. Kamera inayotumika katika mradi huu ni OV2640, ambayo inatoa azimio la saizi 1600x1200. Ingawa inaweza isilingane na ubora wa simu za kisasa, inatosha kwa kazi za msingi za kupiga picha. Ili kufafanua hatua zozote, hakikisha umeangalia video inayoandamana na mafunzo haya (katika video saa 00:00).

Vifaa Vimeelezwa

Vipengele vikuu katika mradi huu vinajumuisha microcontroller ya ESP32, moduli ya kamera (OV2640), na kadi ndogo ya SD kwa ajili ya kuhifadhi. ESP32 ni microcontroller yenye nguvu yenye uwezo wa Wi-Fi na Bluetooth uliojumuishwa, na kuifanya kuwa bora kwa programu za IoT. Moduli ya kamera inapiga picha, ambazo huchakatwa na ESP32.

Kadi ndogo ya SD hufanya kama kifaa cha kuhifadhi picha zilizopigwa. Katika mpangilio huu, ESP32 inawasiliana na moduli ya kamera kwa kutumia pini maalum za GPIO, na picha huhifadhiwa katika muundo wa JPEG kwenye kadi ya SD. Hii inaruhusu kupatikana kwa urahisi na kutazamwa kwa picha baadaye.

• Hakikisha kamera imeelekezwa kwa usahihi wakati wa kuiingiza kwenye bodi ya ESP32.
• Tumia kadi ndogo ya SD yenye uwezo wa GB 32 au chini ili kuepuka matatizo ya utangamano.
• Unganisha GPIO 0 kwa GND kwa hali ya programu.
• Zingatia usambazaji wa umeme ili kuepuka matatizo ya brownout.
• Weka kamera imara wakati wa kupiga picha ili kuepuka picha zisizo wazi.

Maagizo ya Uunganishaji wa Waya

Ili kuunganisha moduli ya kamera ya ESP32, kwanza hakikisha ESP32 imezimwa. Unganisha moduli ya kadi ndogo ya SD kwenye ESP32 kwa kutumia pini zifuatazo: unganisha pini ya CS ya kadi ya SD kwenye GPIO 5 ya ESP32, MOSI kwa GPIO 23, MISO kwa GPIO 19, na SCK kwa GPIO 18. Kisha, unganisha pini za moduli ya kamera kama ifuatavyo: PWDN kwa GPIO 32, XCLK kwa GPIO 0, SIOD kwa GPIO 26, na SIOC kwa GPIO 27. Pini za data ya saizi Y2 hadi Y9 zinapaswa kuunganishwa kwa GPIO 5 kupitia GPIO 39 kama ilivyofafanuliwa katika msimbo wako.

Hakikisha umeunganisha pini za ardhi na nguvu ipasavyo. ESP32 inaweza kuendeshwa na betri iliyojumuishwa kwenye kit. Baada ya uunganishaji wa waya, hakikisha miunganisho ni salama kabla ya kuwasha kifaa. Ukifuata maagizo kwa karibu, unapaswa kuona kamera ikianzishwa kwa usahihi wakati unapopakia msimbo.

Mifano ya Msimbo na Mwongozo

Katika msimbo, tunaanza kwa kujumuisha maktaba muhimu na kufafanua usanidi wa pini za kamera. Kigezo pictureNumber kinaanzishwa ili kufuatilia idadi ya picha zilizopigwa.

int pictureNumber = 0;

void setup() {
  WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0);  // Zima kigundua brownout
  Serial.begin(115200);
  camera_config_t config;
  // Mipangilio ya usanidi wa kamera
  config.ledc_channel = LEDC_CHANNEL_0;
  // Mipangilio ya ziada ya kamera...
}

Kazi ya setup huanzisha mawasiliano ya serial na kusanidi mipangilio ya kamera. Usanidi unajumuisha vigezo kama ledc_channel, pin_d0, na xclk_freq_hz kwa utendaji bora.

Ifuatayo, tunashughulikia mchakato wa kupiga picha kwa kutumia kitanzi kupiga picha nyingi. Data ya picha huhifadhiwa kwenye kadi ya SD kwa jina la faili kulingana na pictureNumber.

for (int shoot = 0; shoot < 5; shoot++) {
    camera_fb_t *fb = esp_camera_fb_get(); // Piga Picha
    String path = "/picture" + String(pictureNumber) + ".jpg"; // Njia ya faili
    File file = fs.open(path.c_str(), FILE_WRITE); // Fungua faili kuandika
    // Andika data ya picha kwenye faili
    file.write(fb->buf, fb->len);
    // Sasisha nambari ya picha kwenye EEPROM
    EEPROM.write(0, pictureNumber);
}

Kitanzi hiki kinapiga hadi picha tano, ambapo kila picha huhifadhiwa kwa jina la faili la kipekee. Matumizi ya EEPROM huruhusu programu kukumbuka nambari ya mwisho ya picha, kuhakikisha kila picha mpya ina kitambulisho cha kipekee.

Maonyesho / Nini cha Kutarajia

Unapotokanisha msimbo, ESP32 itaanzisha kamera na kadi ya SD. Baada ya kubonyeza kitufe cha reset kwenye ESP32, itachukua mfululizo wa picha, ambazo zitahesabiwa kwa mpangilio kutoka 0 hadi 255 kulingana na thamani ya EEPROM. Baada ya kupiga picha, unaweza kuondoa kadi ndogo ya SD na kutazama picha kwenye kompyuta yako.

Makosa ya kawaida ni pamoja na kuhakikisha kadi ndogo ya SD imefomatiwa vizuri na kuingizwa, pamoja na kudumisha msimamo thabiti wa kamera ili kuepuka picha zisizo wazi. Ikiwa utapata matatizo ya kamera kutopiga picha, angalia mara mbili wiring na mipangilio iliyowekwa kwenye msimbo (kwenye video saa 06:45).

Vidokezo vya Muda wa Video

• 00:00 Anza
• 1:39 Utangulizi
• 5:19 Msimbo wa Kamera ya ESP32 umeelezwa
• 11:10 Kuchagua bodi ya ESP32 na bandari ya COM kwenye Arduino IDE
• 12:52 Kupiga picha ndani na nje - jaribio

Bilder

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
}