Placa dezvoltare ESP32-CAM cu CH340G, WIFI, Bluetooth, OV5640 5MP

Placa ESP32-CAM cu camera OV5640 de 5 MP este o placa de dezvoltare ESP32 completa, cu microcontroler, camera, slot de card microSD si antena pe aceeasi placa. Este gandita pentru proiecte de streaming video, supraveghere, fotografie declansata de evenimente si alte aplicatii IoT care au nevoie de o imagine trimisa prin WiFi catre un telefon, un calculator sau un server local.

Fiind o placa ESP32, tutorialul foloseste direct placa ESP32-CAM, programata in Arduino IDE ca "AI Thinker ESP32-CAM", impreuna cu modulul programator CH340G inclus in kit. Nu este nevoie de o alta placa de dezvoltare.

Cum functioneaza:

Camera OV5640 trimite imaginea catre ESP32 pe un bus paralel de 8 biti (pinii D0-D7), insotit de semnalele de sincronizare PCLK, VSYNC si HREF si de busul I2C-compatibil SCCB (SIOD/SIOC) prin care microcontrolerul configureaza rezolutia, expunerea si balansul de alb ale senzorului. ESP32 preia cadrele in memoria PSRAM externa de 4 MB, le comprima in format JPEG folosind encoderul hardware integrat si le pune la dispozitie printr-un server HTTP pornit pe WiFi, la adresa IP primita de la router.

Rezolutia aleasa in cod, de exemplu SVGA (800x600) sau VGA (640x480), determina marimea fiecarui cadru JPEG, deci si viteza de transmitere prin WiFi, de aceea pentru un flux video continuu se foloseste o rezolutie mai mica, iar rezolutia maxima a senzorului OV5640, 2592x1944 (5 MP), se foloseste doar pentru fotografii individuale.

Conectare:

Placa ESP32-CAM se alimenteaza separat la 5 V, iar programarea se face prin modulul programator CH340G, care leaga pinii seriali ai placii la portul USB al calculatorului.

Toata electronica placii lucreaza la 3.3 V, iar modulul programator cu CH340G respecta acelasi nivel logic pe pinii seriali, asa ca nu este nevoie de convertor de nivel intre cele doua placi. Pinul VCC de pe placa ESP32-CAM este o iesire de 3.3 V sau 5 V si nu trebuie folosit pentru a alimenta placa. Alimentarea de 5 V, minim 2 A, este obligatorie pentru functionarea stabila a camerei OV5640, un adaptor USB de calculator fiind de multe ori insuficient pentru functionarea in regim normal, desi acesta poate fi folosit temporar doar pentru programare.

Placa si biblioteci:

Selectati placa "AI Thinker ESP32-CAM" din meniul Tools > Board, dupa ce instalati pachetul "esp32 by Espressif Systems" din Tools > Board > Boards Manager. Daca pachetul nu apare in lista, adaugati adresa https://dl.espressif.com/dl/package_esp32_index.json in File > Preferences, la Additional Boards Manager URLs.

Nu este nevoie sa instalati nicio biblioteca suplimentara din Library Manager. Bibliotecile esp_camera.h, WiFi.h si WebServer.h fac parte din pachetul esp32 instalat mai sus.

Codul:

Codul initializeaza camera cu maparea de pini a modelului AI Thinker, se conecteaza la reteaua WiFi si porneste un server HTTP simplu cu o pagina principala si o adresa de unde se poate descarca o fotografie in format JPEG.

/*
  ESP32-CAM OV5640 5MP - simple snapshot web server
  Board: AI Thinker ESP32-CAM (install package "esp32 by Espressif Systems" from Boards Manager,
  Additional Boards Manager URL: https://dl.espressif.com/dl/package_esp32_index.json)
  Libraries: none to install separately, esp_camera.h, WiFi.h and WebServer.h are part of the esp32 board package
  Wiring: camera and microSD pins are fixed on board, programming uses U0R, U0T, IO0 and GND
  through the included ESP32-CAM-MB CH340G programmer, power is supplied on the 5V/GND pins
*/
#include "esp_camera.h"
#include <WiFi.h>
#include <WebServer.h>
// Camera pin map for the AI Thinker ESP32-CAM board
#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
#define FLASH_LED_GPIO_NUM 4
// WiFi credentials, replace with your own network
const char* ssid = "YOUR_WIFI_SSID";
const char* password = "YOUR_WIFI_PASSWORD";
WebServer server(80);
// Serve a simple HTML page with a link to the snapshot
void handleRoot() {
  String html = "<html><body><h1>ESP32-CAM OV5640</h1>";
  html += "<p><a href=\"/capture\">Get snapshot</a></p></body></html>";
  server.send(200, "text/html", html);
}
// Capture one JPEG frame and send it to the browser
void handleCapture() {
  camera_fb_t *fb = esp_camera_fb_get();
  if (!fb) {
    Serial.println("Camera capture failed");
    server.send(503, "text/plain", "Camera capture failed");
    return;
  }
  server.sendHeader("Content-Disposition", "inline; filename=capture.jpg");
  server.send_P(200, "image/jpeg", (const char *)fb->buf, fb->len);
  esp_camera_fb_return(fb);
  Serial.printf("Snapshot sent, size %u bytes\n", fb->len);
}
void setup() {
  Serial.begin(115200);
  Serial.println();
  // Flash LED pin kept off at startup
  pinMode(FLASH_LED_GPIO_NUM, OUTPUT);
  digitalWrite(FLASH_LED_GPIO_NUM, LOW);
  // Camera configuration structure
  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_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;
  config.pixel_format = PIXFORMAT_JPEG;
  // Use a larger frame and double buffering when PSRAM is available
  if (psramFound()) {
    config.frame_size = FRAMESIZE_SVGA;
    config.jpeg_quality = 12;
    config.fb_count = 2;
  } else {
    config.frame_size = FRAMESIZE_VGA;
    config.jpeg_quality = 15;
    config.fb_count = 1;
  }
  // Initialize the camera
  esp_err_t err = esp_camera_init(&config);
  if (err != ESP_OK) {
    Serial.printf("Camera init failed with error 0x%x\n", err);
    return;
  }
  Serial.println("Camera initialized");
  // Connect to WiFi
  WiFi.begin(ssid, password);
  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());
  // Register HTTP routes and start the server
  server.on("/", handleRoot);
  server.on("/capture", handleCapture);
  server.begin();
  Serial.println("HTTP server started");
  Serial.println("Open the IP address above in a browser, then click Get snapshot");
}
void loop() {
  server.handleClient();
}

Cum functioneaza codul:

La inceputul fisierului sunt definite constantele de pini ale camerei, PWDN_GPIO_NUM, RESET_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, cu valorile fixe folosite pe placa AI Thinker, plus FLASH_LED_GPIO_NUM pentru LED-ul de pe GPIO4. Variabilele ssid si password trebuie completate cu datele retelei WiFi, iar obiectul server, de tip WebServer, este creat pe portul 80.

In functia setup, dupa pornirea comunicatiei seriale, structura camera_config_t este completata cu pinii camerei, formatul de imagine PIXFORMAT_JPEG si, in functie de rezultatul lui psramFound, rezolutia FRAMESIZE_SVGA cu doi bufferi de cadru cand placa are PSRAM, sau FRAMESIZE_VGA cu un singur buffer in caz contrar. Functia esp_camera_init porneste camera, iar in caz de eroare mesajul este afisat pe Serial. Urmeaza conectarea la WiFi cu WiFi.begin, o asteptare in bucla pana cand WiFi.status returneaza WL_CONNECTED, si inregistrarea celor doua rute, handleRoot pentru pagina principala si handleCapture pentru poza, inainte de a porni server.begin.

Functia handleCapture cere un cadru nou cu esp_camera_fb_get, il trimite catre browser cu server.send_P folosind tipul image/jpeg, apoi elibereaza memoria cadrului cu esp_camera_fb_return. In functia loop, server.handleClient este apelata permanent pentru a raspunde cererilor primite prin HTTP.

Rezultat:

Pe Monitorul Serial, la 115200 baud, se vede conectarea la reteaua WiFi si adresa IP primita de placa, apoi confirmarea pornirii serverului HTTP. Accesand adresa IP afisata, urmata de /capture, intr-un browser, se descarca o fotografie facuta in acel moment de camera OV5640.

Camera initialized
Connecting to WiFi.......
WiFi connected, IP address: 192.168.0.115
HTTP server started
Open the IP address above in a browser, then click Get snapshot
Snapshot sent, size 48213 bytes
Snapshot sent, size 51042 bytes

Probleme frecvente:

Nu apare nimic pe Monitorul Serial: verificati ca viteza selectata in Monitorul Serial este 115200 baud si ca modulul programator este conectat corect, cu U0R si U0T neinversate.

Urcarea codului esueaza cu mesaj de conectare sau de sincronizare: tineti apasat butonul Download sau legati GPIO0 la GND inainte de a incepe urcarea, si verificati ca este selectat Flash Mode DIO din Tools > Flash Mode.

Camera nu porneste si apare o eroare de initializare pe Serial: verificati alimentarea de 5 V, minim 2 A, deoarece o sursa slaba duce la resetari (brownout) in momentul initializarii camerei.

Imaginea este alba, intunecata sau are dungi: lasati camera cateva secunde sa isi regleze automat expunerea si balansul de alb, si verificati ca banda FPC a camerei este asezata corect in conector.

Placa se reseteaza singura in timpul streamingului: reduceti rezolutia si calitatea JPEG din cod si verificati din nou sursa de alimentare, un consum de varf de peste 300 mA cu o sursa slaba provoaca resetari repetate.

Camera devine foarte fierbinte la atingere: este un comportament normal al senzorului OV5640, dar montati obligatoriu un radiator pe spate si evitati streamingul continuu pe durate lungi.

Limitari si sfaturi:

Rezolutia maxima de 5 MP a senzorului OV5640 este utila pentru fotografii, nu pentru streaming continuu, unde viteza de transmitere prin WiFi si memoria PSRAM limiteaza practic rezolutia la SVGA sau HD. Modulul nu este recomandat pentru functionare neintrerupta 24/7, iar pentru proiecte cu capturi periodice este indicat sa opriti camera intre poze, folosind GPIO32, pentru a reduce incalzirea si consumul. Pornind de la acest cod, placa poate fi extinsa cu salvare pe cardul microSD, detectie de miscare cu un senzor PIR extern pe unul dintre pinii liberi, sau integrare intr-un sistem mai mare de supraveghere cu mai multe camere ESP32-CAM.