Placa dezvoltare ESP32-CAM, Wifi, Bluetooth, OV5640 5MP

Placa ESP32-CAM cu camera OV5640 de 5 MP este un modul ESP32 cu camera incorporata, folosit pentru a capta si a transmite imagini prin WiFi fara alte componente suplimentare. Se foloseste in proiecte de supraveghere, monitorizare la distanta, fotografiere automata si recunoastere de imagini.

Tutorialul foloseste chiar placa ESP32-CAM AI-Thinker ca platforma, programata din Arduino IDE. Placa nu are port USB, asa ca incarcarea programului se face printr-un adaptor USB-serial FT232RL, iar alimentarea se face separat, de la o sursa de 5 VDC cu minim 2 A. Programul porneste camera si serveste un flux video printr-un server web simplu.

Cum functioneaza:

Senzorul OV5640 capteaza imaginea si o trimite catre ESP32 pe 8 linii de date paralele (D0 - D7), sincronizate de semnalele XCLK (ceasul dat senzorului), PCLK (ceasul pixelilor), VSYNC (inceput de cadru) si HREF (linie valida). Configurarea senzorului, adica rezolutia, expunerea si balansul de alb, se face printr-o magistrala I2C / SCCB pe liniile SIOD (GPIO26) si SIOC (GPIO27). Pinul PWDN (GPIO32) poate opri senzorul cand nu este folosit.

Calculul de mai jos arata de ce imaginea este comprimata JPEG direct in senzor. Rezolutia maxima este 2592 x 1944 = 5 038 848 pixeli. Cu 2 octeti pe pixel (format RGB565), un cadru ar avea putin peste 10 MB (10 077 696 octeti), mai mult decat cei 4 MB de PSRAM ai placii. In JPEG, un cadru ocupa mult mai putin si incape usor in memorie.

La rezolutia SVGA (800 x 600 = 480 000 pixeli), un cadru JPEG are, in functie de scena si de calitatea aleasa in cod, aproximativ 10 - 40 KB. In testele noastre, la calitatea 12, media a fost de aproximativ 13 KB pe cadru. Daca reteaua WiFi ofera in practica 400 KB/s, iar un cadru are 40 KB, rezulta 400 / 40 = 10 cadre pe secunda. Peste rezolutia HD, senzorul livreaza doar 4 - 6 cadre pe secunda cu ceasul XCLK de 20 MHz. Rezolutia maxima ramane astfel rezervata fotografiilor individuale, iar pentru flux video se aleg SVGA sau HD. Biblioteca esp32-camera ofera ca rezolutie maxima QSXGA de 2560 x 1920 pixeli, putin sub cei 2592 x 1944 pixeli ai senzorului.

Conectare:

Placa se alimenteaza de la o sursa separata de 5 VDC cu minim 2 A, pe pinul 5V. Nu o alimentati din adaptorul USB-serial, deoarece adaptorul si portul USB nu asigura curentul de varf cerut de camera OV5640 impreuna cu WiFi-ul, iar iesirea de 3.3 V a adaptorului nu este potrivita pentru aceasta placa. Pinul VCC al adaptorului FT232RL ramane neconectat, iar jumperul adaptorului se pune pe 3.3 V, pentru ca semnalele TXD si RXD sa aiba nivelul logic de 3.3 V al GPIO-urilor ESP32. Liniile seriale se incruciseaza: TXD al adaptorului merge la U0R, iar RXD al adaptorului la U0T. Puntea dintre IO0 si GND se pune doar pe durata incarcarii programului.

Imaginea de mai jos arata conectarea placii la programatorul FT232.

Butoane, reglaje si indicatoare:

Pentru incarcare, legati IO0 la GND, apasati RESET si incarcati programul. Placa a intrat in modul corect daca Arduino IDE porneste incarcarea fara eroarea de conectare.

Dupa incarcare, scoateti puntea dintre IO0 si GND si apasati RESET. Placa ruleaza acum programul, iar in Serial Monitor apar mesajele de pornire.

LED-ul alb ramane stins in program. Daca vreti iluminare suplimentara, comandati GPIO4 din cod, tinand cont ca LED-ul aprins la luminozitate maxima adauga aproximativ 130 mA la consum. In testele noastre, placa cu camera OV5640 a consumat aproximativ 340 - 360 mA la 5 V, cu camera activa si LED-ul stins.

Placa si biblioteci:

In Arduino IDE, mergeti la File - Preferences si adaugati in campul Additional Boards Manager URLs adresa https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json. Deschideti apoi Tools - Board - Boards Manager, cautati esp32 si instalati pachetul esp32 by Espressif Systems, intr-o versiune recenta (2.0.x sau mai noua).

Dupa instalare, selectati placa AI Thinker ESP32-CAM din Tools - Board - esp32. Capturile de mai jos ilustreaza pasii de configurare din Arduino IDE.

Nu trebuie instalata nicio biblioteca din Library Manager, deoarece esp_camera.h si WiFi.h vin odata cu pachetul esp32 by Espressif Systems.

Codul:

Programul initializeaza camera cu maparea de pini a placii AI-Thinker, se conecteaza la reteaua WiFi si trimite fluxul video JPEG catre un client conectat pe portul 80. Inlocuiti numele si parola retelei inainte de incarcare.

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

Cum functioneaza codul:

Prima parte contine definitiile. Constantele WIFI_SSID si WIFI_PASSWORD retin datele retelei, iar liniile cu PWDN_GPIO_NUM, XCLK_GPIO_NUM, SIOD_GPIO_NUM, SIOC_GPIO_NUM, Y2_GPIO_NUM - Y9_GPIO_NUM, VSYNC_GPIO_NUM, HREF_GPIO_NUM si PCLK_GPIO_NUM descriu pinii dintre ESP32 si conectorul camerei, aceiasi ca in tabelul din descriere. FLASH_LED_GPIO_NUM este GPIO4, iar obiectul server asculta pe portul 80.

Functia startCamera() completeaza structura camera_config_t cu pinii camerei, cu ceasul XCLK de 20 MHz si cu formatul PIXFORMAT_JPEG. Structura porneste golita (= {}), astfel incat campurile nesetate sa nu contina valori aleatoare. Daca psramFound() returneaza adevarat, se alege FRAMESIZE_SVGA cu doua buffere de cadru in PSRAM (fb_count = 2) si modul CAMERA_GRAB_LATEST, care trimite mereu cel mai nou cadru. Altfel se alege FRAMESIZE_CIF cu un singur buffer in memoria interna. Dupa esp_camera_init() functia citeste senzorul cu esp_camera_sensor_get(), afiseaza identificatorul PID, care pentru OV5640 este 0x5640, si avertizeaza daca senzorul conectat este altul.

Functia skipRequest() citeste si ignora antetul cererii HTTP trimise de browser, pana la prima linie goala. Functia streamTo() trimite antetul multipart/x-mixed-replace, apoi repeta in bucla: preia un cadru cu esp_camera_fb_get(), trimite separatorul, tipul si lungimea, scrie datele JPEG cu client.write() si elibereaza bufferul cu esp_camera_fb_return(). Bucla se opreste cand clientul se deconecteaza.

In setup() se porneste Serial la 115200 baud, se mentine LED-ul alb stins, se apeleaza startCamera(), se conecteaza placa la WiFi cu WiFi.begin() si se afiseaza adresa IP primita. In loop() programul asteapta un client cu server.available() si, cand apare unul, ii serveste fluxul prin streamTo().

Rezultat:

Deschideti Serial Monitor la 115200 baud. Dupa pornire trebuie sa apara confirmarea initializarii camerei cu PID 0x5640, apoi adresa IP a placii. Introduceti adresa in browser si va aparea imaginea in timp real.

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

Probleme frecvente:

Incarcarea se opreste cu o eroare de conectare. Cauza obisnuita este modul de pornire gresit. Verificati ca IO0 este legat la GND, apasati RESET inainte de incarcare si verificati ca TXD merge la U0R si RXD la U0T, nu direct.

Dupa incarcare nu se intampla nimic si in Serial Monitor apare un mesaj despre asteptarea incarcarii programului. Puntea dintre IO0 si GND a ramas pusa. Scoateti-o si apasati RESET.

Placa se reseteaza continuu sau apare mesajul Brownout detector was triggered. Alimentarea este insuficienta, de obicei pentru ca placa este alimentata din USB sau cu o sursa slaba. Folositi o sursa stabila de 5 VDC cu minim 2 A, cu cabluri scurte.

Apare mesajul Camera init failed cu un cod de eroare. Cablul flex al camerei nu este introdus complet sau clapeta conectorului FPC nu este inchisa. Deconectati alimentarea, reintroduceti cablul cu contactele in pozitia corecta si inchideti clapeta.

Imaginea are zgomot sau o nuanta violet dupa un timp de functionare. Senzorul OV5640 s-a incalzit prea mult. Montati un radiator pe spatele camerei, asigurati ventilatie si reduceti rezolutia la SVGA sau HD.

Placa se conecteaza la WiFi, dar imaginea se blocheaza sau are putine cadre pe secunda. Semnalul WiFi este slab sau rezolutia este prea mare. Apropiati placa de router si reduceti rezolutia din cod.

Limitari si sfaturi:

Modulul nu este recomandat pentru streaming continuu 24 de ore din 24, deoarece camera OV5640 se incalzeste puternic pe aceasta placa. Motivul este ca placa a fost proiectata pentru camera OV2640 si alimenteaza conectorul camerei cu 3.3 V, 2.8 V si 1.2 V, in timp ce OV5640 isi alimenteaza nucleul de la un regulator intern de 1.5 V pornit din 3.3 V. Diferenta de tensiune se transforma in caldura chiar in senzor, iar peste aproximativ 50 grade C pot aparea zgomot si o nuanta violet in imagine.

Fara modificari hardware, folositi un radiator pe camera, rezolutii de cel mult SVGA sau HD in streaming si treceti senzorul in standby intre capturi prin registrul 0x3008 (valoarea 0x42 pentru standby si 0x02 pentru activ). In testele noastre, consumul placii a scazut de la aproximativ 338 mA la 163 mA cu senzorul in standby. Rezolutia maxima oferita de biblioteca, 2560 x 1920 pixeli, este potrivita pentru fotografii.

Utilizatorii cu experienta in lipirea componentelor SMD pot reduce incalzirea inlocuind regulatorul de 1.2 V de langa conectorul camerei cu unul de 1.5 V (de exemplu XC6206P152MR sau ME6206A15XG) si dezactivand din software regulatorul intern al senzorului, prin bitul 3 al registrului 0x3031 (valoarea 0x08), imediat dupa esp_camera_init(). Dupa aceasta modificare, radiatorul camerei a ramas vizibil mai rece in testele noastre.

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

Nu dezactivati regulatorul intern pe o placa nemodificata, deoarece nucleul senzorului ar functiona sub tensiunea minima, cu risc de imagini corupte si blocari. O placa modificata nu mai este potrivita pentru camera OV2640 si trebuie marcata corespunzator.

Pe baza acestui tutorial puteti construi o camera de supraveghere cu acces din browser, un sistem de fotografiere periodica cu salvare pe cardul microSD sau un proiect de recunoastere a obiectelor, folosind GPIO-urile libere pentru senzori de miscare sau alte module.