ESP32-CAM development board with CH340G, WiFi, Bluetooth, OV5640 5MP

The ESP32-CAM board with OV5640 5 MP camera is an ESP32 module with a built-in camera, used to capture and transmit images over WiFi without any additional components. It is used in surveillance projects, remote monitoring, automatic photography and image recognition.

The tutorial uses the AI-Thinker ESP32-CAM board as the platform, programmed from the Arduino IDE. The board has no USB port, so the program is uploaded through an FT232RL USB-to-serial adapter, and the power is supplied separately from a 5 VDC source with at least 2 A. The program starts the camera and serves a video stream through a simple web server.

How it works:

The OV5640 sensor captures the image and sends it to the ESP32 over 8 parallel data lines (D0 - D7), synchronized by the XCLK signals (the clock given to the sensor), PCLK (the pixel clock), VSYNC (frame start) and HREF (valid line). The sensor configuration, that is the resolution, exposure and white balance, is done over an I2C / SCCB bus on the SIOD (GPIO26) and SIOC (GPIO27) lines. The PWDN pin (GPIO32) can shut down the sensor when it is not in use.

The calculation below shows why the image is JPEG compressed directly in the sensor. The maximum resolution is 2592 x 1944 = 5 038 848 pixels. With 2 bytes per pixel (RGB565 format), one frame would be a little over 10 MB (10 077 696 bytes), more than the 4 MB of PSRAM on the board. In JPEG, a frame takes up much less and fits easily in memory.

At SVGA resolution (800 x 600 = 480 000 pixels), a JPEG frame is, depending on the scene and the quality set in the code, approximately 10 - 40 KB. In our tests, at quality 12, the average was about 13 KB per frame. If the WiFi network delivers 400 KB/s in practice, and a frame is 40 KB, this gives 400 / 40 = 10 frames per second. Above HD resolution, the sensor delivers only 4 - 6 frames per second with the 20 MHz XCLK clock. The maximum resolution therefore remains reserved for individual photos, and for video streaming SVGA or HD is chosen. The esp32-camera library offers QSXGA, 2560 x 1920 pixels, as its maximum resolution, slightly below the 2592 x 1944 pixels of the sensor.

Connection:

The board is powered from a separate 5 VDC source with at least 2 A, on the 5V pin. Do not power it from the USB-to-serial adapter, because the adapter and the USB port cannot supply the peak current required by the OV5640 camera together with WiFi, and the adapter's 3.3 V output is not suitable for this board. The VCC pin of the FT232RL adapter stays unconnected, and the adapter jumper is set to 3.3 V, so that the TXD and RXD signals have the 3.3 V logic level of the ESP32 GPIOs. The serial lines cross over: the TXD of the adapter goes to U0R, and the RXD of the adapter to U0T. The jumper between IO0 and GND is placed only while the program is being uploaded.

The image below shows how the board is connected to the FT232 programmer.

Buttons, settings and indicators:

For uploading, connect IO0 to GND, press RESET and upload the program. The board has entered the correct mode if the Arduino IDE starts the upload without the connection error.

After uploading, remove the jumper between IO0 and GND and press RESET. The board now runs the program, and the startup messages appear in the Serial Monitor.

The white LED stays off in the program. If you want additional lighting, control GPIO4 from the code, keeping in mind that the LED at maximum brightness adds approximately 130 mA to the consumption. In our tests, the board with the OV5640 camera consumed approximately 340 - 360 mA at 5 V, with the camera active and the LED off.

Board and libraries:

In the Arduino IDE, go to File - Preferences and add in the Additional Boards Manager URLs field the address https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json. Then open Tools - Board - Boards Manager, search for esp32 and install the esp32 by Espressif Systems package, in a recent version (2.0.x or newer).

After installation, select the AI Thinker ESP32-CAM board from Tools - Board - esp32. The screenshots below illustrate the configuration steps in the Arduino IDE.

No library needs to be installed from the Library Manager, because esp_camera.h and WiFi.h come with the esp32 by Espressif Systems package.

The code:

The program initializes the camera with the pin mapping of the AI-Thinker board, connects to the WiFi network and sends the JPEG video stream to a client connected on port 80. Replace the network name and password before uploading.

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

How the code works:

The first part contains the definitions. The constants WIFI_SSID and WIFI_PASSWORD hold the network details, and the lines with PWDN_GPIO_NUM, XCLK_GPIO_NUM, SIOD_GPIO_NUM, SIOC_GPIO_NUM, Y2_GPIO_NUM - Y9_GPIO_NUM, VSYNC_GPIO_NUM, HREF_GPIO_NUM and PCLK_GPIO_NUM describe the pins between the ESP32 and the camera connector, the same as in the table in the description. FLASH_LED_GPIO_NUM is GPIO4, and the server object listens on port 80.

The startCamera() function fills the camera_config_t structure with the camera pins, the 20 MHz XCLK clock and the PIXFORMAT_JPEG format. The structure starts empty (= {}), so that the fields that are not set do not contain random values. If psramFound() returns true, FRAMESIZE_SVGA is chosen with two frame buffers in PSRAM (fb_count = 2) and the CAMERA_GRAB_LATEST mode, which always sends the newest frame. Otherwise FRAMESIZE_CIF is chosen with a single buffer in the internal memory. After esp_camera_init(), the function reads the sensor with esp_camera_sensor_get(), prints the PID identifier, which for the OV5640 is 0x5640, and warns if the connected sensor is a different one.

The skipRequest() function reads and ignores the HTTP request header sent by the browser, up to the first empty line. The streamTo() function sends the multipart/x-mixed-replace header, then repeats in a loop: it gets a frame with esp_camera_fb_get(), sends the boundary, the type and the length, writes the JPEG data with client.write() and releases the buffer with esp_camera_fb_return(). The loop stops when the client disconnects.

In setup(), Serial is started at 115200 baud, the white LED is kept off, startCamera() is called, the board connects to WiFi with WiFi.begin() and the received IP address is printed. In loop() the program waits for a client with server.available() and, when one appears, serves it the stream through streamTo().

Result:

Open the Serial Monitor at 115200 baud. After startup, the confirmation of the camera initialization with PID 0x5640 should appear, followed by the IP address of the board. Enter the address in the browser and the real-time image will appear.

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

Common problems:

The upload stops with a connection error. The usual cause is the wrong boot mode. Check that IO0 is connected to GND, press RESET before uploading and check that TXD goes to U0R and RXD to U0T, not directly.

After uploading, nothing happens and a message about waiting for the program upload appears in the Serial Monitor. The jumper between IO0 and GND was left in place. Remove it and press RESET.

The board resets continuously or the message Brownout detector was triggered appears. The power supply is insufficient, usually because the board is powered from USB or from a weak source. Use a stable 5 VDC source with at least 2 A, with short cables.

The message Camera init failed appears with an error code. The camera flex cable is not fully inserted or the FPC connector latch is not closed. Disconnect the power, reinsert the cable with the contacts in the correct position and close the latch.

The image has noise or a purple tint after a period of operation. The OV5640 sensor has overheated. Mount a heatsink on the back of the camera, ensure ventilation and reduce the resolution to SVGA or HD.

The board connects to WiFi, but the image freezes or has few frames per second. The WiFi signal is weak or the resolution is too high. Move the board closer to the router and reduce the resolution in the code.

Limitations and tips:

The module is not recommended for continuous streaming 24 hours a day, because the OV5640 camera heats up strongly on this board. The reason is that the board was designed for the OV2640 camera and supplies the camera connector with 3.3 V, 2.8 V and 1.2 V, while the OV5640 powers its core from an internal 1.5 V regulator driven from 3.3 V. The voltage difference turns into heat right in the sensor, and above approximately 50 degrees C noise and a purple tint can appear in the image.

Without hardware modifications, use a heatsink on the camera, resolutions of at most SVGA or HD in streaming, and put the sensor into standby between captures through register 0x3008 (value 0x42 for standby and 0x02 for active). In our tests, the consumption of the board dropped from approximately 338 mA to 163 mA with the sensor in standby. The maximum resolution offered by the library, 2560 x 1920 pixels, is suitable for photos.

Users experienced in soldering SMD components can reduce the heating by replacing the 1.2 V regulator next to the camera connector with a 1.5 V one (for example XC6206P152MR or ME6206A15XG) and by disabling the internal sensor regulator from software, through bit 3 of register 0x3031 (value 0x08), right after esp_camera_init(). After this modification, the camera heatsink stayed noticeably cooler in our tests.

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

Do not disable the internal regulator on an unmodified board, because the sensor core would operate below its minimum voltage, with the risk of corrupted images and crashes. A modified board is no longer suitable for the OV2640 camera and must be marked accordingly.

Based on this tutorial you can build a surveillance camera with browser access, a periodic photography system with saving to a microSD card, or an object recognition project, using the free GPIOs for motion sensors or other modules.