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

Az ESP32-CAM kártya 5 MP-es OV5640 kamerával egy beépített kamerával rendelkező ESP32 modul, amely további alkatrészek nélkül képes képeket rögzíteni és WiFi-n keresztül továbbítani. Felügyeleti rendszerekben, távoli megfigyelésben, automatikus fényképezésben és képfelismerési projektekben használják.

A tutorial a 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 adapterrel töltjük fel, a tápellátás pedig külön, legalább 2 A-es 5 VDC tápegységről történik. A program elindítja a kamerát, és egy egyszerű webszerveren keresztül videofolyamot szolgáltat.

Hogyan működik:

Az OV5640 szenzor rögzíti a képet, és 8 párhuzamos adatvonalon (D0 - D7) küldi az ESP32-nek, amelyeket az XCLK (a szenzornak adott órajel), a PCLK (a pixelek órajele), a VSYNC (képkocka kezdete) és a HREF (érvényes sor) jelek szinkronizálnak. 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 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át. JPEG formátumban egy képkocka sokkal kevesebb helyet foglal, így könnyen elfér a memóriában.

SVGA felbontáson (800 x 600 = 480 000 pixel) egy JPEG képkocka a jelenettől és a kódban beállított minőségtől függően körülbelül 10 - 40 KB. Saját teszteinkben a 12-es minőségnél a képkockánkénti átlag körülbelül 13 KB volt. Ha a WiFi-hálózat a 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 csak 4 - 6 képkocka/másodperc sebességet ad 20 MHz-es XCLK órajellel. A maximális felbontás ezért az egyedi fényképekre marad fenn, a videofolyamhoz pedig az SVGA vagy a HD felbontást érdemes választani. Az esp32-camera könyvtár maximális felbontásként QSXGA-t, 2560 x 1920 pixelt kínál, ami kicsit kevesebb, mint a szenzor 2592 x 1944 pixeles felbontása.

Csatlakoztatás:

A kártyát külön, legalább 2 A-es 5 VDC tápegységről kell táplálni 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ítsa, hogy a TXD és RXD jelek az ESP32 GPIO-inak 3.3 V-os logikai szintjével egyezzenek. A soros vonalak keresztben vannak kötve: az adapter TXD lába az U0R-re, az adapter RXD lába az U0T-re megy. Az IO0 és GND közötti hidat csak a program feltöltése idejére helyezze be.

Az alábbi kép a kártya FT232 programozóhoz való 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 került, ha az Arduino IDE a feltöltést csatlakozási hiba nélkül elindítja.

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

A fehér LED a programban kikapcsolva marad. Ha további megvilágításra van szüksége, vezérelje a GPIO4-et a kódból, de vegye figyelembe, hogy a maximális fényerőn égő LED körülbelül 130 mA-rel növeli a fogyasztást. Saját méréseink szerint az OV5640 kamerás kártya körülbelül 340 - 360 mA-t fogyasztott 5 V-on, a kamera aktív és a LED kikapcsolt állapotában.

Kártyacsomag és könyvtárak:

Az Arduino IDE-ben lépjen a File - Preferences menübe, és az Additional Boards Manager URLs mezőbe írja be a https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json címet. Ezután nyissa meg a Tools - Board - Boards Manager menüpontot, keresse meg az esp32 csomagot, és telepítse az esp32 by Espressif Systems csomagot egy 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ás lépéseit mutatják az Arduino IDE-ben.

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

A kód:

A program a AI-Thinker kártya lábkiosztásával inicializálja a kamerát, csatlakozik a WiFi-hálózathoz, és a 80-as porton csatlakozó kliensnek JPEG videofolyamot 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 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 írják le az ESP32 és a kameracsatlakozó közötti lábakat, megegyezően a leírás táblázatával. A FLASH_LED_GPIO_NUM értéke a GPIO4, a server objektum pedig a 80-as porton figyel.

A startCamera() függvény feltölti a camera_config_t struktúrát a kamera lábaival, a 20 MHz-es XCLK órajellel és a PIXFORMAT_JPEG formátummal. A struktúra üresen indul (= {}), így a be nem állított mezők nem tartalmaznak véletlen értékeket. Ha a psramFound() igaz értéket ad, akkor FRAMESIZE_SVGA felbontást választ két képkocka-pufferrel a PSRAM-ban (fb_count = 2) és a CAMERA_GRAB_LATEST módot, amely mindig a legfrissebb képkockát küldi. Ellenkező esetben FRAMESIZE_CIF felbontást választ 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 beolvassa a szenzort, kiírja a PID azonosítót, amely az OV5640 esetén 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: az esp_camera_fb_get() segítségével vesz egy képkockát, elküldi az elválasztót, a típust és a hosszt, a JPEG adatot a client.write() segítségével írja ki, és az esp_camera_fb_return() függvénnyel felszabadítja a puffert. A ciklus akkor áll le, amikor a kliens lecsatlakozik.

A setup() függvényben a Serial 115200 baudon indul, a fehér LED kikapcsolva marad, meghívódik a startCamera(), a kártya a WiFi.begin() függvénnyel csatlakozik a WiFi-hez, és kiírja a kapott IP-címet. A loop() függvény a server.available() függvénnyel vár kliensre, és amikor megjelenik egy, a streamTo() függvénnyel kiszolgálja a videofolyamot.

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, 0x5640 PID-del, majd a kártya IP-címének. Írja be a címet a böngészőbe, és megjelenik a valós idejű kép.

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. A gyakori ok a rossz indítási mód. Ellenőrizze, hogy az IO0 GND-re van kötve, nyomja meg a RESET gombot a feltöltés előtt, és ellenőrizze, hogy a TXD az U0R-re, az RXD pedig az U0T-re megy, nem közvetlenül.

Feltöltés után nem történik semmi, és a Serial Monitorban a program feltöltésére való várakozásról szóló üzenet jelenik meg. Az IO0 és GND közötti híd bent maradt. Vegye ki, majd nyomja meg a RESET gombot.

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

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

A kép zajos lesz, vagy lila árnyalatú 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 megakad, 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, 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 kameracsatlakozó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-ból működtetett belső 1.5 V-os szabályozóról kapja. A feszültségkülönbség hő formájában magában a szenzorban jelenik meg, és körülbelül 50 Celsius-fok felett zaj és lila á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 helyezze standby állapotba (0x42 érték a standby-hoz és 0x02 az aktívhoz). Saját méréseinkben a kártya fogyasztása körülbelül 338 mA-ről 163 mA-re csökkent, a szenzor standby állapotában. A könyvtár által kínált maximális felbontás, 2560 x 1920 pixel, fényképekhez megfelelő.

Az SMD alkatrészek forrasztásában jártas felhasználók csökkenthetik a melegedést úgy, hogy a kameracsatlakozó melletti 1.2 V-os szabályozót 1.5 V-osra cserélik (például XC6206P152MR vagy ME6206A15XG típusra), és a belső szenzorszabályozót a szoftverből kikapcsolják a 0x3031 regiszter 3. bitjének (0x08 érték) beállításával, közvetlenül az esp_camera_init() után. Ezt a módosítást követően saját méréseink szerint a kamera hűtőbordája láthatóan 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
}

Nem módosított kártyán ne kapcsolja ki a belső szabályozót, 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.

Ezen tutorial alapján építhet böngészőből elérhető megfigyelő kamerát, időszakos fényképező rendszert microSD kártyára mentéssel, vagy tárgyfelismerő projektet a szabad GPIO-k segítségével mozgásérzékelő szenzorokhoz vagy más modulokhoz.