ESP32-CAM és OV2640

Bevezető

Az OV7670 jelű kamera projektem elkészítése óta eltelt pár év. Örömmel vettem Tóth Andrásnak, a Mikrovezérlő Blog és Webáruház tulajdonosa felkérését, hogy választhatok egy eszközt a készletből, és készítsek róla leírást. Mivel korábban nagyon nehézkes volt a kamera használata, ezen viszont egyből látszott, hogy lényegesen egyszerűbb lesz, erre esett a választásom. Megvásárolható a https://www.microcontroller.hu/termek/esp32-cam-ov2640-kameraval/ oldalon.

Szükséges eszközök

Az alábbiakra lesz szükségünk a projekt végrehajtásához:

  • ESP32-CAM mikrokontroller OV2640 kamerával,
  • internetkapcsolat (vagy Arduino IDE és az ESP32 alaplapok telepítve kell, hogy legyenek),
  • wifi (nem elég a LAN, muszáj a wifi hálózat),
  • laptop,
  • (USB-TTL átalakító és 5 anya-anya kábel) VAGY (Arduino UNO és 4 anya-apa, 1 anya-anya és 1 apa-apa kábel és USB kábel az Arduino UNO számítógépre kötéséhez).

Az Arduino IDE beállítása

Telepítés

Ha még nem tettük meg, töltsük le és telepítsük az Arduono IDE-t a https://www.arduino.cc/en/software oldalról.

Beállítások

Az Arduino UNO alapból nem támogatja az ESP32 lapkákat, így (az ESP8266 családhoz hasonlóan) azt külön be kell állítani.

Edit → Preferences: az Additional Boards Manager URLs:

Ide írjuk be az alábbit:

https://dl.espressif.com/dl/package_esp32_index.json

Sok esetben már az ESP8266 család lapkáinak a leírója benne van; ez esetben vesszővel választhatjuk el:

https://dl.espressif.com/dl/package_esp32_index.json, http://arduino.esp8266.com/stable/package_esp8266com_index.json

Alaplapok betöltése

Tools → Boards → Boards Manager…

A keresőbe írjuk be ezt: {{esp32}}, majd telepítsük. Ez hosszú ideig eltart és nagy mennyiségű adatot tölt a hálózatról, így célszerű korlátlan netes elérésű hálzatóról végrehajtani ezt a lépést.

Alaplap beállítások

Tools → Boards → ESP32 Wrover Module

Sajnos elég nehéz megtalálni, ugyanis nagyon sokféle ESP32 lapka létezik. Az Arduino IDE frissebb verzióiban legalább típus szerint almenükbe szedtél (alap, ESP8266, ESP32), a korábbiakban viszont mindez ömlesztve van, ráadásul nem is ábécé sorrendben.

Az alábbiakat állítsuk be (szinte mindet át kell állítani):

  • Upload Speed: 115200
  • Flash Frequency: 40MHz
  • Flash Mode: QIO
  • Partition Scheme: Huge APP (3MB No OTA/1MP SPIFFS)
  • Core Debug Level: None
  • Port: rákötés után megjelenik valami, majd azt kell kiválasztani (tehát egyvalami jelenik meg, de ki kell választani)
  • Programmer: AVR ISP

Bekötés

Az ESP32-CAM eszközön nincs USB port, közvetlenül tehát nem tudjuk rákötni a számítógépre. Két lehetőségünk van: vagy USB-TTL átalakítót használunk, vagy egy Arduino UNO-t (vagy hasonlót).

USB-TTL átalakító

Az alábbi bekötést valósítsuk meg:

ESP32-CAM USB-TTL
GND GND
5V 5V
U0R TX
U0T RX

ESP32-CAM GPIO0 → ESP32-CAM GND

(A kép forrása: https://randomnerdtutorials.com/esp32-cam-take-photo-save-microsd-card/.)

Dugjuk be az USB-TTL átalakítót a számítógép valamelyik USB portjára. Érdemes az Eszközkezelőn belül megnézni a Portokat; elvileg ott láthatjuk:

(Az enyémen azt jelzi, hogy már nem támogatott, de azért még nagyon jól működik.)

Arduino UNO lapka használata

A fenti alternatívája ez a megoldás (tehát a félreértések elkerülése érdekében: vagy az egyik, vagy a másik, nem kell mindkettő). Vegyünk egy Arduino UNO vagy hasonló lapkát (Én történetesen WeMos R1 D1-et használtam), majd valósítsuk meg az alábbi bekötést:

 

ESP32-CAM Arduino
GND GND
5V 5V
U0R TX
U0T RX

 ESP32-CAM GPIO0 → ESP32-CAM GND

 Arduino RESET → Arduino GND

 

(A képet a neten találtam, egy ouTube videó képernyőképeként; a kép forrása a bal alsó sarkában található felirat alapján a https://easyelectronicsproject.com/ oldal.)

Dugjuk rá az Arduino-t a számítógépre.

Megjegyzések

A flash mode-ot (mindkét esetben) a ESP32-CAM GPIO0 → GND biztosítja. Olyan videóval is találkoztam, amely kihangsúlyozta, hogy meg kell nyomni a Reset gombot ahhoz, hogy flash módba kerüljön. Azt én is tapasztaltam egyszer, hogy enélkül nem indult el az írás, bár ekkor néhány másodperc után leállt, ugyanakkor volt sikeres feltöltésem a Reset megnyomása nélkül is. Szóval ezt ki kell tapasztalni.

Több leírásban nem az 5 Volt, hanem a 3,3 Volt szerepel, ill. van olyan is, amely azt állítja, hogy a számítógép 5 Voltja nem elegendő, külső tápra van szükség. Ez utóbbi úgy néz ki, hogy az USB számítógépre és áramba is be van dugva egyszerre.

Web szerver

A program feltöltése

Az első projekt a web szerver, melynek a kódja megtalálható a példaprogramok között az Arduino IDE-ben:

File → Examples → ESP32 → Camera → CameraWebServer

Néhány dolgot módosítanunk kell.

A CameraWebServer.cpp fájl 10-14. soraiban #define makrók találhatóak. Alapértelmezésben a #define CAMERA_MODEL_WROVER_KIT van kiválasztva. Azt tegyük megjegyzésbe, és vegyük ki a megjegyzésből a #define CAMERA_MODEL_AI_THINKER-t:

// Select camera model
//#define CAMERA_MODEL_WROVER_KIT
//#define CAMERA_MODEL_ESP_EYE
//#define CAMERA_MODEL_M5STACK_PSRAM
//#define CAMERA_MODEL_M5STACK_WIDE
#define CAMERA_MODEL_AI_THINKER

A 18. és 19. sorban az alábbi két sort látjuk:

const char* ssid = "*********";
const char* password = "*********";

A csillagok helyére írjuk be a mi wifink azonosítóját és jelszavát. Ugyanazt a hálózatot adjuk meg, amivel a számítógépünkkel csatlakozunk.

Mentsük le a módosított projektet (File → Save); az alapértelmezett könyvtár megteszi, de választhatunk másikat is.

Ha még nem tettük meg, kössük rá az USB-TTL átalakítót vagy az Arduino-t. Győződjünk meg arról, hogy a Tools → Ports alatt a megfelelő van kiválasztva.

Töltsük fel a kódot:

Sketch → Upload

Ha nem indul, nyomjuk meg a Reset gombot.

A fordítás és a feltöltés is eltart egy jódarabig, nagyságrendileg egy percig. A sikeres feltöltést az alábbi jelzi:

Leaving...
Hard resetting via RTS pin...

Több olyan videót is láttam, ahol a feltöltés során hibaüzenetre panaszkodtak; ezt én nem tapasztaltam.

A program indítása

Sikeres feltöltés után húzzuk ki a ESP32-CAM GPIO0 → GND kábelt, ill. Arduino UNO használata esetén az Arduino RESET → Arduino GND kábelt is. Nyissuk meg a serial monitort.

Tools → Serial Monitor

A Baud Rate-et állítsuk 115200-ra, majd nyomjuk meg az ESP32-n a Reset gombot. Ha minden rendben ment, a lentihez hasonló üzenetet kell látnunk:

Az alsó sorban a Camera Ready! után kiír egy IP címet; a példában ez http://192.168.1.73/; ezt jegyezzük fel.

Most már kihúzhatjuk a TX és RX kábeleket, elég, ha csak tápot és GND-t kap az ESP32-CAM, és nem is feltétlenül kell, hogy a számtógép USBjére kapcsolódjon, akár egy konnektoros USB átalakítóba is bedughatjuk.

Nyissuk meg egy böngészővel a fenti oldalt. (A számítógép ugyanarra a wifi hálózatra legyen csatlakozva, mint amit megadtunk az ESP32-CAM-nek.) A következő nyílik meg:

Kapcsoljuk be lent a stream-et (Start Stream). Fent jó eséllyel meg fog jelenni egy kicsi homályos kép. A felbontást (Resolution) állítsuk magasabbra. A kamera lencséjét forgatva próbáljuk élesíteni a képet

Kellő kitartással egy ilyen képet is elérhetünk:

ESP32-CAM és OV2640 - Beállítások

Képek készítése

Képet a lenti Get Still segítségével tudunk készíteni; érdemes először azt megnyomni, és nem a stream-ből menteni. Játsszunk el kicsit a lehetőségekkel! Néhány lehetőség, amire rájöttem:

  • Resolution: a kép felbontása.
  • Quality: képminőség (jó eséllyel a jpeg minősége).
  • Brightness: világosság (mivel elég durva egységekben lehet csak módosítani, a gyakorlatban használhatatlan).
  • Contrast: kontraszt (szintúgy, bár itt ez már használhatóbb).
  • Saturation: színtelítettség.
  • Special Effect: különleges hatások, pl. negatív, szépia stb.
  • WB: a fehéregyensúly beállításával kapcsolatos lehetőségek.
  • H- és V-Mirror: tükrözések.
  • Face Detection és Face Recognition: arcfelismerés; ezt nem sikerült működésre bírnom.

Néhány kép, amit készítettem; egyiken sincs semmilyen utófeldolgozás.

Városkép:

ESP32-CAM és OV2640 - Távoli látkép

Makró:

ESP32-CAM és OV2640 - Normál kép

Szépia:

ESP32-CAM és OV2640 - Szépia kép

Lehetséges problémák

Használat során számos probléma adódhat; itt most csak párat sorolok fel.

Furcsa hibaüzenetek vagy csíkozódás jelenik meg: ez az instabil áramforrásra utal. Ez esetben célszerű a hálózati áramaforrásra dugható USB átalakítót használni.

A stream megakad: újra kell indítani, esetleg az oldalt újra be kell tölteni, esetleg az ESP32-CAM-et is újra kell indítani.

Problémát okozhat az is, hogy messze van a wifi jeltől, és “leszakad”; ez esetben beszerezhetünk külső antennát.

Mentés MicroSD kártyára

Érdemes kihasználni a beépített microSD kártyaolvasót! Ehhez szerezzünk be egy microSD kártyát. Csatlakoztassuk a számítógéphez (ehhez szükség lehet egy USB-microSD vagy SD-microSD átalakítóra) és formázzuk le: Fájlkezelő → az “Ez a gép” alatt keressük meg a megfelelő lemezt (ez általában az E, vagy azt nem sokkal követő betűjelű meghajtó lesz) → jobb kattintás → Formázás… Érdemes tudni, hogy az ESP32 csak 4 GB-ig tudja kezelni a microSD kártyát. (Annál nagyobbat is használhatunk, de csak az alsó 4 GB-ot fogja “látni”.)

Program

Ezt a projektet a https://randomnerdtutorials.com/esp32-cam-take-photo-save-microsd-card/ oldal alapján készítettem; a példaprogram is onnan származik. A beállítás és a bekötés megegyezik az előzővel, a program viszont az alábbi:

#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             // 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: %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); // payload (image), payload length
    Serial.printf("Saved file to path: %s\n", 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() {
  
}

A program működése: látható, hogy a loop() üres: valójában ez úgy működik, hogy elindul, beállítja magát, készít egy képet (a “vaku” is villan), azt elmenti az SD kártyára, majd “mély alvó” módba kerül. Érdemes megfigyelni azt, hogy a sorszámot az EEPROM-ban tárolja, ami megmarad akkor is, ha nem kap áramot.

Használat

Feltöltés után csak tápot kapjon (5V + GND), a többi kábelre (TX, RX, flash mód) nincs szükség. Ha még nem tettük meg, helyezzünk be egy microSD kártyát, irányítsuk a fotózandó témára a kamerát, majd nyomjuk meg a Reset gombot. Ha minden rendben ment, akkor a vaku villan, és elkészít egy fotót. Ezt többször is megismételhetjük. A probléma viszont leginkább az, hogy nem látjuk az eredményt. Ahhoz ki kell vennünk a kártyafoglalatból a kártyát, és rá kell csatlakoztatnunk a számtógépre. Só eséllyel nem egy jól megvilágított, éles képet fogunk látni, hanem egy sötét “pacát”. Próbáljuk meg csavargatni a lencsét az élesítéshez.

Eredmény

Kicsit “vakon” próbálgatva a következő legjobb minőséget sikerült elérnem:

ESP32-CAM és OV2640 - SD-re mentés

Szóval ez a lehetőség egyelőre inkább még csak érdekes mint hasznos.

Előnyök

Ennyi tapasztalat után foglaljuk össze az eszköz előnyeit!

  • A mikrokontroller tudása: nagyságrendekkel az Arduino UNO felett.
    • Memória: a Flash memória mérete 4 MB. Emlékeztetőül: az Arduino UNO memóriája 32 kB. Az SRAM memória mérete is ekkora nagyságrenddel nagyobb.
    • A lábak száma: abból kevesebb van, mindössze 16 (az Arduino UNO-n 32), ráadásul ezekből csak 9 használható általános célra, viszont azt is érdemes figyelembe venni, hogy Arduino UNO-val szinte nem marad láb üresen, ha egy kamerát csatlakoztatunk hozzá, az egyebekről (pl. wifi, kártyaolvasó) nem is beszélve. Tehát az ESP-CAM-mel anélkül tudunk értelmes projekteket készíteni, hogy a tápon kívül akár egyetlen másik lábat felhasználnánk.
    • Kiegészítők: aki már próbálkozott Arduino UNO-val mindenféle projektekkel, az különösen értékeli azt, hogy az ESP32 integráltan tartalmaz wifit, MicroSD kártya olvasót, Bluetooth-ot, egy vakut (szinte már zavaróan nagy fényerejű LED-et) és külső antenna foglalatot is.
  • A kamera tudása: hasonló nagyságrendi ugrás tapasztalható az OV7670 és az OV2640 között is.
    • OV7670 0,3 megapixeles, míg az OV2640 2 megapixeles.
    • Az OV7670 fekete-fehér képeket készít, míg az OV2640 színest.
    • Az OV7670 csak BMP képet készített, míg az OV2640 számos lehetőséget biztosít: többféle formátum, stream-elés, alap beállítások (pl. fényerő, fehéregyensúly stb.), sőt, még arcfelismerés is van benne, bár azt nekem nem sikerült beüzemelnem.
  • Bekötés: a korábban kipróbált, OV7670 jelű eszközhöz 23 kapcsolatot kellett létrehozni, ami tehát legalább 23 kábelt jelentett. Ráadásul ez csak a kamera összekapcsolását jelentette az Arduino-val. Így a gyakorlatban azt használhatatlanná tette. Itt viszont egy vékony fóliát kell megfelelően ráhelyezni a mikrokontrollerre, és az minden szükséges kapcsolatot tartalmaz. Ennek a jelentőségét az nem is igazán értheti meg, aki nem kínlódott a másikkal.
  • Ár: az integrált mikrokontroller és a kamera együttes ára 10 dollár alatti, és ez igaz a fent megadott magyar kiskereskedelmi árra is. Azt gondolom, hogy – figyelembe véve a fenti tudást – nyugodt szívvel kijelenthetjük, hogy filléres tétel.

A benne rejlő perspektíva szinte félelmetes!

Hátrányok

Nem tudunk elmenni az eszköz hátrányai mellett sem. Nemcsak amiatt, mert úgymond illik hátrányokat is írni a kiegyensúlyozottság látszatát fenntartva, hanem valóban vannak neki.

  • IDE problémák:
    • Az Arduino IDE alapból nem támogatja az ESP32-es mikrokontroller családot. Ez persze nem az ESP32 hibája, hanem az Arduino IDE-é, de egy felhasználót hol kell, hogy ez érdekelje? Lehet persze mondani, hogy nem kötelező Arduino IDE-t használni, lehet mást is, pl. PlatformIO-t, de annak még hosszabb a betanulási görbéje. És egy projekt megvalósításakor a legkevésbé az integrált fejlesztőkörnyezetet szeretnénk tanulni!
    • Szinte semelyik alapértelmezett vagy logikus beállítás nem megfelelő, gondosan át kell állítani sokmindent.
  • Az ESP32-CAM hardver problémái
    • USB hiánya: nem lehet közvetlenül számítógépre kötni, kell egy köztes eszköz, pl. egy USB-TTL átalakító (vagy FTDI programozó). Ami azért nyilván alapeszköz, de mégsem annyira, mint mondjuk egy csavarhúzó. Személy szerint én elvárnék pl. egy mikro USB foglalatot, még akkor is, ha ennek következtében valamelyest meg kell növelni a lapka méretét.
    • Nehezen hozzáférhető power gomb: érdemes lett volna picit hozzáférhetőbb helyre tenni.
    • Nehezen olvasható pinek: egyrészt nagyon pici, másrészt nem azon az oldalon van a felirat, ahol a tű.
  • A kamera gyengeségei
    • Könnyen romló hatást kelt: egy vékony fóliában vannak a kábelek; az embernek az az érzése, hogy egy rossz mozdulattal tönkre teszi
    • A lencse nehezen csavarható, akadozik: legalábbis nálam. Kezdeti problémák miatt valójában kettőt is kaptam, és mindkettőnél csak kombináltfogóval sikerült megmozdítanom, és utána is nehézkesen csavarható puszta kézzel, ha egyáltalán.
    • Nem stabil, magyarán lötyög. Jó lenne, ha fixen bele lehetne pattintani a kamera fejét is magára a mikrokontrollerre, hogy legalább ahhoz képest ne mozdulhasson el.
    • Tudásban még mindig van hova fejlődni: habár óriási az előrelépés a korábbihoz képest még mindig nem éri el azt a szintet, hogy hétköznapi célokra használni lehessen. A legnagyobb probléma szerintem az élesség; egy automatikus élesség állítás sokat dobna rajta.
    • Az eredmény lehetne szebb: még egy belépő szintű okostelefon kamerájától is messze elmarad.
  • Feltöltési problémák
    • Elárulok egy kulisszatitkot: az első eszköz, amit kaptam, egyáltalán nem működött, különböző hibaüzenetekkel leállt. A másodiknál, amit kaptam, már elindult a feltöltés, de pár másodperc elteltével leállt. Kipróbáltam egy másik számítógéppel: ott egyáltalán nem működött. Egy harmadik számítógépen az elsőként használt USB-vel nem működött, végül ott egy másik USB-vel sikerült csak feltöltenem. Szóval nagyon nehézkes, és ha valakinek csak egy számítógépe van, akkor egyáltalán nem biztos, hogy tudni fogja használni. Azzal a számítógéppel, amellyel nem működött az ESP32-CAM, szépen működött pl. a WeMos.
    • A feltöltés során rengeteg hibaüzenettel lehet találkozni: szinte ahány YouTube videó készült a témában, annyi problémáról számoltak be. Hol az IDE írt ki hibát, “de azt figyelmen kívül kell hagyni”, hol a tápellátás nem volt megfelelő (külső tápra volt szükség), de olyan is volt, hogy az induláskor esett végtelen ciklusba.
    • A fordítás és a feltöltés is hosszú ideig tart. Ennek a pontos ideje persze számítógép függő, ám a nagyságrend perces. Ez elfogadhatatlanul hosszú idő egy fejlesztés során, amikor esetleg minden apró változtatást ki szeretnénk próbálni.
    • Nincs egyértelműen ajánlott módja a fejlesztésnek. Lehet 3,3 Voltot használni, de 5 Voltot is. Használhatunk Arduino UNO-t (vagy más lapkát) a számítógépre kötéshez, de USB-TTL átalakítót is. Használhatjuk az Arduino UNO-t, a PlatformIO-t, vagy a gyártó saját fejlesztőeszközét. Csakhogy a nagy szabadság oda vezet, hogy egy adott konfigurációra esetleg nem találunk segítséget, ha elakadunk. Szerintem sokkal jobb lenne egy egyértelműen javasolt megoldás.
  • Csúnya kód: a kód önmagában nehezen érthető.
    • CameraWebServer.cpp: nagyon sok a konfiguráció. Csak a konfiguráció 40 soron keresztül történik. Pl. egy esp_camera_init(ESP-32-OV2640); szerintem tökéletesen elég kellene, hogy legyen; mindenki tudná, hogy miről van szó. Azt is problémának tartom, hogy a CAMERA_MODEL_WROVER_KIT van alapból kiválasztva, viszont még nem találkoztam olyannal, aki nem CAMERA_MODEL_AI_THINKER-t használna. Legyen az az alapértelmezett, a többit meg rejtsék el!
    • app_httpd.cpp: ez egy hosszú, nehezen érthető kód. Érzésem szerint jó része mehetne a könyvtárba.
    • camera_index.h: ez oly mértékben kritikán aluli, hogy ha osztályzatot kellene adnom az egész projektre, már önmagában ez megakadályozná, hogy átmenőt adjak: ez nem más, mint egy gzippelt index.html oldal bájtjainak a felsorolása. Legyen már ott egy normális HTML oldal!
    • camera_pins.h: szerintem felesleges. Tekintettel arra, hogy a pin kiosztás a kialakításból adódóan eleve adott, azokat library szinten kellene lefixálni, és elrejteni a fejlesztő elől. Azt a pár típust konstansként fel kellene sorolni, egy konfigurációban megadni, és minden mást a könyvtárnak kellene intéznie.
  • Üzemeltetési problémák
    • Instabil webszerver: gyakran megszakad a kapcsolat, leáll a stream-elés; ennek sok esetben az ESP32-CAM fizikai újraindítása a megoldás. (Ez a tény önmagában kizárja az eszköz megfigyelő kameraként történő alkalmazását.)
    • Csíkozódás: a kép sokszor csúnya, csíkos lesz. Ez tápellátási problémákra vezethető vissza

Összegzés

Hatalmas tudású eszköz filléres árért, ám még van hová fejlődnie. Még hobbielektronikai mércével mérve is kifejezetten macerás a használata, és elfogadhatatlanul instabil. Arra még semmiképpen sem alkalmas, hogy mondjuk egy iskolai szakkör keretein belül szerettessük meg a diákokkal a mikroelektronikát, és arra se, hogy ennek segítségével olyan okosházat építsünk, melyben nem egy kellően “megszállott”, mikrokontrollerekkel álmodó ember él.

Ugyanakkor ha lesz még egy akkora lépés, mint ami volt az OV7670 és az OV2640 között (ill. az Arduino UNO és az ESP-CAM között; és miért ne lenne), akkor az már megfelelő lesz árban, tudásban és stabilitásban is ahhoz, hogy akár oktatási, akár gyakorlati célokra felhasználjuk. Az az érzésem, hogy ezzel a cikkel picit előre szaladtunk az időben (magyarán_: a világ még nem tart itt), de pár év múlva ismét érdemes lesz ránézni az aktuális lehetőségre, és remélhetőleg elkészül a következő fejezet, melyben arról tudok majd beszámolni, hogy mennyire olcsó, nagy tudás és könnyen használható eszközt sikerült kipróbálnom.

Ez a cikk a http://faragocsaba.hu/esp32-cam oldalon is megjelent.

(Statisztika: 470 megtekintés)