ESP32-CAM development board, Wi‑Fi, Bluetooth, OV5640 5MP

The ESP32-CAM board with the 5MP OV5640 camera is an ESP32 development module with a built-in camera. It is used to capture and transmit images over WiFi without any additional components. This tutorial uses the ESP32-CAM AI-Thinker board as the platform, together with Arduino IDE, to upload a program that starts the camera and serves a simple video stream through an internal web server.

Because the board has no USB port of its own, uploading the program requires an external USB-to-serial adapter, such as the FT232, connected to the serial pins of the board.

How it works:

The OV5640 sensor captures the image over the 8 parallel data lines D0-D7, synchronized by the XCLK, PCLK, VSYNC and HREF signals. The sensor is configured (resolution, exposure, white balance) through an I2C/SCCB link on the SIOD and SIOC lines. The sensor compresses the image into JPEG format before the ESP32 reads it, which greatly reduces the amount of data compared to a raw image.

At SVGA resolution (800 x 600 pixels), a JPEG frame is roughly 20 - 50 KB, depending on the scene and on the quality level chosen in the code. Dividing a typical local WiFi bandwidth of a few hundred KB/s by this frame size gives a stream of a few frames per second. This is enough for video monitoring, but well below the maximum capability of the 2592 x 1944 pixel sensor, which is reserved for individual photos.

Wiring:

The board is programmed through an FT232 adapter connected to the serial pins of the ESP32-CAM, with the adapter's voltage jumper set to 5V. The IO0 pin is temporarily connected to GND only while the code is being uploaded.

Board and libraries:

In Arduino IDE, go to File - Preferences and add the address https://dl.espressif.com/dl/package_esp32_index.json in the Additional Boards Manager URLs field. Then open Tools - Board - Boards Manager, search for esp32 and install the esp32 by Espressif Systems package.

After installation, select the AI Thinker ESP32-CAM board from Tools - Board - ESP32 Arduino.

You do not need to install any additional library, because esp_camera.h and WiFi.h are included automatically with the esp32 by Espressif Systems package.

The code:

The code below initializes the camera with the AI-Thinker board pin mapping, connects to the WiFi network and sends the video stream to any client connected on port 80.

/*
  ESP32-CAM (AI-Thinker) with OV5640 5MP camera - WiFi video stream example
  Board: "AI Thinker ESP32-CAM" (Tools > Board > ESP32 Arduino)
  Board package: esp32 by Espressif Systems, installed from Boards Manager
  Boards Manager URL: https://dl.espressif.com/dl/package_esp32_index.json
  Libraries: esp_camera.h and WiFi.h, both included with the esp32 package, no extra library required
  Upload wiring: FT232 VCC->5V, FT232 GND->GND, FT232 TXD->U0R, FT232 RXD->U0T, IO0 bridged to GND only during upload
*/
#include "esp_camera.h"
#include <WiFi.h>
// ---- Wi-Fi credentials ----
const char* ssid = "YOUR_WIFI_SSID";
const char* 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
WiFiServer server(80);
void startCamera() {
  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_SVGA;   // 800x600, good balance for streaming
    config.jpeg_quality = 12;             // lower number = higher quality, bigger file
    config.fb_count = 2;
  } else {
    config.frame_size = FRAMESIZE_CIF;
    config.jpeg_quality = 15;
    config.fb_count = 1;
  }
  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");
}
void sendStreamToClient(WiFiClient &client) {
  client.println("HTTP/1.1 200 OK");
  client.println("Content-Type: multipart/x-mixed-replace; boundary=frame");
  client.println();
  while (client.connected()) {
    camera_fb_t * fb = esp_camera_fb_get();
    if (!fb) {
      Serial.println("Frame capture failed");
      break;
    }
    client.println("--frame");
    client.println("Content-Type: image/jpeg");
    client.printf("Content-Length: %u\n\n", fb->len);
    client.write(fb->buf, fb->len);
    client.println();
    esp_camera_fb_return(fb);
    if (!client.connected()) break;
  }
}
void setup() {
  Serial.begin(115200);
  Serial.println();
  startCamera();
  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());
  Serial.println("Open this address in a browser to view the live stream");
  server.begin();
}
void loop() {
  WiFiClient client = server.available();
  if (client) {
    Serial.println("New client connected");
    sendStreamToClient(client);
    client.stop();
    Serial.println("Client disconnected");
  }
}

How the code works:

At the beginning of the file, the WiFi network credentials (ssid, password) and the camera pins for the AI-Thinker board are defined (PWDN_GPIO_NUM, XCLK_GPIO_NUM, Y2_GPIO_NUM - Y9_GPIO_NUM, VSYNC_GPIO_NUM, HREF_GPIO_NUM, PCLK_GPIO_NUM, SIOD_GPIO_NUM, SIOC_GPIO_NUM).

The startCamera function fills in the camera_config_t structure with these pins and selects the FRAMESIZE_SVGA resolution. It also uses two frame buffers when the board has PSRAM available. Then it calls esp_camera_init and prints on Serial whether the initialization succeeded.

The sendStreamToClient function sends the connected client a multipart/x-mixed-replace HTTP header. Then, as long as the client stays connected, it grabs one JPEG frame at a time with esp_camera_fb_get, sends it over the connection and releases it with esp_camera_fb_return.

In the setup function, the serial port is initialized, the camera is started, the board waits to connect to the WiFi network and prints the IP address it received. Then the WiFiServer server is started on port 80. In the loop function, the board waits for a new client and sends it the video stream through sendStreamToClient.

Result:

Open Serial Monitor at 115200 baud. After the camera is initialized and the board connects to the network, the board's IP address will be displayed. When you open this address in a browser, the live video stream from the camera will appear.

Camera initialized
Connecting to WiFi.....
WiFi connected, IP address: 192.168.0.114
Open this address in a browser to view the live stream
New client connected
Client disconnected
New client connected
Client disconnected

Common problems:

If Serial Monitor shows nothing, check that the selected speed is 115200 baud and that you removed the connection between IO0 and GND before pressing RESET after the upload.

If an error message appears at startup during camera initialization (camera init failed), check that the camera's flex ribbon is firmly seated in the FPC connector and was not displaced when the heatsink was fitted.

If the board resets by itself or brownout messages appear in Serial Monitor, the power supply is too weak. Replace it with a 5V supply rated for at least 2A, connected directly to the 5V pin.

If the board does not connect to the WiFi network, check that you entered the network name and password correctly and that the WiFi signal is strong enough where the board is installed.

If the image is very dark or full of noise, provide a better light source in the scene, because the camera has no lighting of its own apart from the flash LED.

If the code upload fails with messages about failing to connect to the board, redo the IO0-GND jumper and press RESET again exactly when Arduino IDE starts the upload.

Limitations and tips:

The OV5640 camera reaches its maximum 5MP resolution only for individual photos. For continuous streaming, lower resolutions such as SVGA or HD are recommended, to keep a reasonable number of frames per second.

The board has no USB port of its own, so programming always requires an external USB-to-serial adapter. Also, without the autofocus version, the camera works with a fixed focus.

The sensor gets noticeably warm during operation, which is why the board is not recommended for continuous 24/7 video streaming. It is better suited to monitoring and intermittent captures, with a heatsink fitted and good ventilation.

This setup can be used as a base for projects such as WiFi surveillance cameras, monitoring stations that save images to a microSD card, or simple object recognition systems that process images on an external server.