ESP32-CAM fejlesztőpanel, WiFi, Bluetooth, OV5640 5 MP

Az ESP32-CAM kártya az OV5640 5 MP-es kamerával egy beépített kamerával rendelkező ESP32 modul, amelyet képek rögzítésére és WiFi-n keresztüli továbbítására használnak további alkatrészek nélkül. Megfigyelő, távoli felügyeleti, automatikus fényképezési és képfelismerési projektekben alkalmazzák.

Az oktatóanyag az AI-Thinker ESP32-CAM kártyát használja platformként, amelyet az Arduino IDE-ből programozunk. A kártyának nincs USB portja, ezért a programot egy FT232RL USB-soros adapteren keresztül töltjük fel, a tápellátás pedig külön történik, legalább 2 A-es 5 VDC tápegységről. A program elindítja a kamerát, és egy egyszerű webszerveren keresztül video folyamot szolgáltat.

Működés:

Az OV5640 szenzor rögzíti a képet, és 8 párhuzamos adatvonalon (D0 - D7) küldi az ESP32-nek. Az adatátvitelt az XCLK (a szenzornak adott órajel), a PCLK (a pixelek órajele), a VSYNC (képkocka kezdete) és a HREF (érvényes sor) jelek szinkronizálják. A szenzor konfigurálása, vagyis a felbontás, az expozíció és a fehéregyensúly beállítása I2C / SCCB buszon történik a SIOD (GPIO26) és a SIOC (GPIO27) vonalakon. A PWDN (GPIO32) láb leállíthatja a szenzort, ha nincs használatban.

Az alábbi számítás megmutatja, miért tömörítik a képet JPEG formátumba közvetlenül a szenzorban. A maximális felbontás 2592 x 1944 = 5 038 848 pixel. Pixelenként 2 bájttal (RGB565 formátum) egy képkocka valamivel több mint 10 MB lenne (10 077 696 bájt), ami meghaladja a kártya 4 MB-os PSRAM-jának méretét. JPEG formátumban egy képkocka sokkal kevesebb helyet foglal, és könnyen elfér a memóriában.

SVGA felbontásnál (800 x 600 = 480 000 pixel) egy JPEG képkocka a jelenettől és a kódban megadott minőségtől függően nagyjából 10 - 40 KB. Saját teszteinkben a 12-es minőségnél a képkockák átlagos mérete körülbelül 13 KB volt. Ha a WiFi-hálózat gyakorlatban 400 KB/s sebességet biztosít, és egy képkocka 40 KB, akkor 400 / 40 = 10 képkocka másodpercenként. A HD felbontás felett a szenzor 20 MHz-es XCLK órajellel csak 4 - 6 képkockát ad másodpercenként. A maximális felbontás így az egyedi fényképekre marad fenn, a video folyamhoz pedig SVGA vagy HD felbontást érdemes választani. Az esp32-camera könyvtár maximális felbontásként QSXGA-t kínál, 2560 x 1920 pixellel, ami kicsit kisebb a szenzor 2592 x 1944 pixeles felbontásánál.

Csatlakoztatás:

A kártyát külön, legalább 2 A-es 5 VDC tápegységről táplálja az 5V lábon. Ne az USB-soros adapterről táplálja, mert az adapter és az USB-port nem biztosítja az OV5640 kamera és a WiFi együttes csúcsáramát, az adapter 3.3 V-os kimenete pedig nem alkalmas erre a kártyára. Az FT232RL adapter VCC lába nincs bekötve, az adapter jumperét 3.3 V-ra állítjuk, hogy a TXD és az RXD jelek az ESP32 GPIO-inak 3.3 V-os logikai szintjét használják. A soros vonalak keresztbe vannak kötve: az adapter TXD lába az U0R-re, az adapter RXD lába az U0T-re kerül. Az IO0 és a GND közötti hidat csak a program feltöltése idejére tesszük be.

Az alábbi kép a kártya FT232 programozóhoz történő csatlakoztatását mutatja.

Gombok, beállítások és jelzőfények:

Feltöltéshez kösse az IO0-t GND-re, nyomja meg a RESET gombot, majd töltse fel a programot. A kártya helyes módba lépett, ha az Arduino IDE hibaüzenet nélkül elindítja a feltöltést.

Feltöltés után távolítsa el az IO0 és a GND közötti hidat, majd nyomja meg a RESET gombot. A kártya most a programot futtatja, a Serial Monitorban pedig megjelennek az indítási üzenetek.

A fehér LED a programban kikapcsolva marad. Ha extra megvilágításra van szükség, vezérelje a GPIO4-et a kódból, figyelembe véve, hogy a maximális fényerőn égő LED körülbelül 130 mA-rel növeli a fogyasztást. Saját teszteinkben az OV5640 kamerával szerelt kártya körülbelül 340 - 360 mA-t fogyasztott 5 V-on, aktív kamera és kikapcsolt LED mellett.

Kártya és könyvtárak:

Az Arduino IDE-ben nyissa meg a File - Preferences menüpontot, és az Additional Boards Manager URLs mezőbe írja be ezt a címet: https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json. Ezután nyissa meg a Tools - Board - Boards Manager menüpontot, keressen rá az esp32 kifejezésre, és telepítse az esp32 by Espressif Systems csomagot, friss, 2.0.x vagy újabb verzióban.

A telepítés után válassza ki az AI Thinker ESP32-CAM kártyát a Tools - Board - esp32 menüből. Az alábbi képernyőképek a beállítási lépéseket mutatják az Arduino IDE-ben.

Nem kell könyvtárat telepíteni a Library Managerből, mert az esp_camera.h és a WiFi.h az esp32 by Espressif Systems csomaggal együtt érkezik.

A kód:

A program a kamerát az AI-Thinker kártya lábkiosztásával inicializálja, csatlakozik a WiFi-hálózathoz, és a 80-as porton csatlakozó kliensnek JPEG video folyamot küld. A feltöltés előtt cserélje ki a hálózat nevét és jelszavát.

/*
  ESP32-CAM (AI-Thinker) with OV5640 5MP camera - WiFi MJPEG video stream
  Board selected in Arduino IDE: "AI Thinker ESP32-CAM" (Tools > Board > esp32)
  Board package: esp32 by Espressif Systems (installed from Boards Manager)
  Boards Manager URL (File > Preferences): https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
  Libraries: none to install, esp_camera.h and WiFi.h come with the esp32 package
  Upload wiring: FT232 TXD -> U0R, FT232 RXD -> U0T, FT232 GND -> GND,
                 5V supply (min 2 A) on the 5V pin, IO0 bridged to GND only during upload
*/
#include "esp_camera.h"
#include <WiFi.h>
// ---- Wi-Fi credentials (replace with your own) ----
const char* WIFI_SSID = "YOUR_WIFI_SSID";
const char* WIFI_PASSWORD = "YOUR_WIFI_PASSWORD";
// ---- AI-Thinker camera pin map ----
#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
// White flash LED on GPIO4 (also SD card DATA1)
#define FLASH_LED_GPIO_NUM 4
WiFiServer server(80);
// Configure and start the camera
bool startCamera() {
  camera_config_t config = {};          // start from a zeroed structure
  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_sccb_sda = SIOD_GPIO_NUM;
  config.pin_sccb_scl = SIOC_GPIO_NUM;
  config.pin_pwdn = PWDN_GPIO_NUM;
  config.pin_reset = RESET_GPIO_NUM;
  config.xclk_freq_hz = 20000000;        // 20 MHz clock for the sensor
  config.pixel_format = PIXFORMAT_JPEG;  // the sensor compresses the image itself
  if (psramFound()) {
    config.frame_size = FRAMESIZE_SVGA;  // 800x600, a good balance for streaming
    config.jpeg_quality = 12;            // lower number = better quality, bigger file
    config.fb_count = 2;                 // two frame buffers for smoother streaming
    config.fb_location = CAMERA_FB_IN_PSRAM;
    config.grab_mode = CAMERA_GRAB_LATEST;  // always send the newest frame
    Serial.println("PSRAM found, using SVGA with 2 frame buffers");
  } else {
    config.frame_size = FRAMESIZE_CIF;
    config.jpeg_quality = 15;
    config.fb_count = 1;
    config.fb_location = CAMERA_FB_IN_DRAM;
    config.grab_mode = CAMERA_GRAB_WHEN_EMPTY;
    Serial.println("No PSRAM, using CIF with 1 frame buffer");
  }
  esp_err_t err = esp_camera_init(&config);
  if (err != ESP_OK) {
    Serial.printf("Camera init failed with error 0x%x\n", err);
    return false;
  }
  // Read the sensor ID to confirm which camera is attached
  sensor_t *s = esp_camera_sensor_get();
  Serial.printf("Camera init OK, sensor PID: 0x%04X\n", s->id.PID);
  if (s->id.PID != OV5640_PID) {
    Serial.println("Warning: the attached sensor is not an OV5640");
  }
  return true;
}
// Read and ignore the HTTP request header sent by the browser
void skipRequest(WiFiClient &client) {
  unsigned long start = millis();
  while (client.connected() && millis() - start < 1000) {
    if (client.available()) {
      String line = client.readStringUntil('\n');
      if (line.length() <= 1) break;  // blank line ends the header
    }
  }
}
// Send frames to the client until it disconnects
void streamTo(WiFiClient &client) {
  client.print("HTTP/1.1 200 OK\r\n");
  client.print("Content-Type: multipart/x-mixed-replace; boundary=frame\r\n\r\n");
  Serial.println("Streaming started");
  uint32_t frames = 0;
  while (client.connected()) {
    camera_fb_t *fb = esp_camera_fb_get();  // get one JPEG frame
    if (!fb) {
      Serial.println("Frame capture failed");
      break;
    }
    size_t len = fb->len;
    client.print("--frame\r\n");
    client.print("Content-Type: image/jpeg\r\n");
    client.printf("Content-Length: %u\r\n\r\n", (unsigned)len);
    size_t sent = client.write(fb->buf, len);
    client.print("\r\n");
    esp_camera_fb_return(fb);               // give the buffer back to the driver
    if (sent != len) break;                 // client is gone
    frames++;
  }
  Serial.printf("Client disconnected after %u frames\n", (unsigned)frames);
}
void setup() {
  Serial.begin(115200);
  delay(500);
  Serial.println();
  Serial.println("ESP32-CAM OV5640 stream example");
  // Keep the white flash LED off
  pinMode(FLASH_LED_GPIO_NUM, OUTPUT);
  digitalWrite(FLASH_LED_GPIO_NUM, LOW);
  if (!startCamera()) {
    return;  // stop here if the camera did not start
  }
  // Connect to Wi-Fi
  WiFi.mode(WIFI_STA);
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  WiFi.setSleep(false);  // no Wi-Fi power saving, better for streaming
  Serial.print("Connecting to WiFi");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println();
  Serial.print("WiFi connected, IP address: ");
  Serial.println(WiFi.localIP());
  Serial.print("Open http://");
  Serial.print(WiFi.localIP());
  Serial.println("/ in a browser to see the stream");
  server.begin();
}
void loop() {
  WiFiClient client = server.available();  // wait for a browser
  if (client) {
    Serial.println("Client connected");
    skipRequest(client);
    streamTo(client);
    client.stop();
  }
}

A kód működése:

Az első rész a definíciókat tartalmazza. A WIFI_SSID és a WIFI_PASSWORD állandók a hálózat adatait tárolják, a PWDN_GPIO_NUM, XCLK_GPIO_NUM, SIOD_GPIO_NUM, SIOC_GPIO_NUM, Y2_GPIO_NUM - Y9_GPIO_NUM, VSYNC_GPIO_NUM, HREF_GPIO_NUM és PCLK_GPIO_NUM sorok pedig az ESP32 és a kamera csatlakozója közötti lábakat írják le, ugyanúgy, ahogy a leírás táblázatában szerepelnek. A FLASH_LED_GPIO_NUM értéke GPIO4, a server objektum pedig a 80-as porton figyel.

A startCamera() függvény kitölti a camera_config_t szerkezetet a kamera lábaival, a 20 MHz-es XCLK órajellel és a PIXFORMAT_JPEG formátummal. A szerkezet üresen indul (= {}), így a be nem állított mezők nem tartalmaznak véletlen értékeket. Ha a psramFound() igaz értéket ad vissza, a program a FRAMESIZE_SVGA felbontást választja, két képkocka-pufferrel a PSRAM-ban (fb_count = 2), valamint a CAMERA_GRAB_LATEST módot, amely mindig a legfrissebb képkockát küldi. Ellenkező esetben a FRAMESIZE_CIF felbontás kerül kiválasztásra, egyetlen pufferrel a belső memóriában. Az esp_camera_init() után a függvény az esp_camera_sensor_get() segítségével olvassa ki a szenzort, kiírja a PID azonosítót, amely az OV5640 esetében 0x5640, és figyelmeztet, ha a csatlakoztatott szenzor más típusú.

A skipRequest() függvény beolvassa és eldobja a böngésző HTTP kérésének fejlécét, az első üres sorig. A streamTo() függvény elküldi a multipart/x-mixed-replace fejlécet, majd ciklusban ismétli: lekér egy képkockát az esp_camera_fb_get() segítségével, elküldi az elválasztót, a típust és a hosszt, kiírja a JPEG adatokat a client.write() függvénnyel, és felszabadítja a puffert az esp_camera_fb_return() hívással. A ciklus akkor áll meg, ha a kliens lecsatlakozik.

A setup() függvényben elindul a Serial 115200 baud sebességgel, a fehér LED kikapcsolva marad, meghívódik a startCamera(), a kártya csatlakozik a WiFi-hez a WiFi.begin() segítségével, és kiírja a kapott IP-címet. A loop() függvényben a program a server.available() hívással kliensre vár, és ha érkezik egy, a streamTo() segítségével kiszolgálja a video folyamot.

Eredmény:

Nyissa meg a Serial Monitort 115200 baud sebességgel. Indítás után meg kell jelennie a kamera inicializálásának visszaigazolásának a 0x5640 PID-del, majd a kártya IP-címének. Írja be a címet a böngészőbe, és megjelenik a kép valós időben.

ESP32-CAM OV5640 stream example
PSRAM found, using SVGA with 2 frame buffers
Camera init OK, sensor PID: 0x5640
Connecting to WiFi......
WiFi connected, IP address: 192.168.1.57
Open http://192.168.1.57/ in a browser to see the stream
Client connected
Streaming started
Client disconnected after 412 frames

Gyakori problémák:

A feltöltés csatlakozási hibával áll le. Gyakori oka a rossz indítási mód. Ellenőrizze, hogy az IO0 GND-re van kötve, nyomja meg a RESET gombot feltöltés előtt, és ellenőrizze, hogy a TXD az U0R-re, az RXD pedig az U0T-re megy, és nem közvetlenül.

Feltöltés után nem történik semmi, a Serial Monitorban pedig a programfeltöltésre való várakozás üzenete jelenik meg. Az IO0 és a GND közötti híd bent maradt. Vegye ki, majd nyomja meg a RESET gombot.

A kártya folyamatosan újraindul, vagy megjelenik a Brownout detector was triggered üzenet. A táplálás elégtelen, általában azért, mert a kártyát USB-ről vagy gyenge tápegységről látják el. Használjon stabil, legalább 2 A-es 5 VDC tápegységet, rövid kábelekkel.

A Camera init failed üzenet hibakóddal jelenik meg. A kamera szalagkábele nincs teljesen bedugva, vagy a FPC csatlakozó zárófüle nincs lezárva. Kapcsolja le a tápellátást, dugja vissza a kábelt az érintkezőkkel a helyes irányban, és zárja le a fület.

A kép zajos lesz, vagy lilás árnyalatot kap egy idő működés után. Az OV5640 szenzor túlmelegedett. Szereljen hűtőbordát a kamera hátoldalára, biztosítson szellőzést, és csökkentse a felbontást SVGA-ra vagy HD-re.

A kártya csatlakozik a WiFi-hez, de a kép akad, vagy kevés képkocka jön másodpercenként. A WiFi-jel gyenge, vagy a felbontás túl nagy. Vigye közelebb a kártyát a routerhez, és csökkentse a felbontást a kódban.

Korlátok és tanácsok:

A modul nem ajánlott folyamatos, napi 24 órás streamelésre, mert az OV5640 kamera ezen a kártyán erősen melegszik. Az ok az, hogy a kártyát az OV2640 kamerához tervezték, és a kamera csatlakozóját 3.3 V-tal, 2.8 V-tal és 1.2 V-tal táplálja, míg az OV5640 a magját a 3.3 V-ról működő belső 1.5 V-os szabályozóról kapja. A feszültségkülönbség hő formájában a szenzorban jelenik meg, és körülbelül 50 Celsius-fok felett zaj és lilás árnyalat jelenhet meg a képen.

Hardveres módosítás nélkül használjon hűtőbordát a kameránál, streamelésnél legfeljebb SVGA vagy HD felbontást, és a befogások között a szenzort a 0x3008 regiszteren keresztül kapcsolja standby üzemmódba (0x42 érték a standby-hoz, 0x02 az aktív üzemmódhoz). Saját teszteinkben a kártya fogyasztása körülbelül 338 mA-ről 163 mA-re csökkent, miközben a szenzor standby üzemmódban volt. A könyvtár által kínált maximális felbontás, 2560 x 1920 pixel, fényképezésre alkalmas.

Az SMD alkatrészek forrasztásában jártas felhasználók csökkenthetik a melegedést úgy, hogy a kamera csatlakozója melletti 1.2 V-os szabályozót 1.5 V-osra cserélik (például XC6206P152MR vagy ME6206A15XG típussal), és szoftveresen kikapcsolják a szenzor belső szabályozóját a 0x3031 regiszter 3. bitjén keresztül (0x08 érték), közvetlenül az esp_camera_init() után. Ezt a módosítást követően saját teszteinkben a kamera hűtőborda észrevehetően hidegebb maradt.

// Only on a board where the DVDD regulator was replaced with a 1.5 V one
sensor_t *s = esp_camera_sensor_get();
if (s->id.PID == OV5640_PID) {
  s->set_reg(s, 0x3031, 0x08, 0x08);  // bypass the internal 1.5 V core regulator
}

Ne kapcsolja ki a belső szabályozót egy módosítatlan kártyán, mert a szenzor magja a minimális feszültség alatt működne, ami sérült képekhez és lefagyásokhoz vezethet. A módosított kártya már nem alkalmas OV2640 kamerához, ezért megfelelően meg kell jelölni.

Ez az oktatóanyag alapján építhet böngészőből elérhető megfigyelő kamerát, microSD kártyára mentő időzített fényképező rendszert, vagy objektumfelismerő projektet, a szabad GPIO-kat pedig mozgásérzékelő szenzorokhoz vagy más modulokhoz használhatja.